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

import * as z from "zod/v4";
import { remap as remap$ } from "../lib/primitives.js";
import { safeParse } from "../lib/schemas.js";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import {
  DeploymentSetupPolicy,
  DeploymentSetupPolicy$inboundSchema,
} from "./deploymentsetuppolicy.js";
import {
  EncryptedStackInputValue,
  EncryptedStackInputValue$inboundSchema,
} from "./encryptedstackinputvalue.js";
import { SDKValidationError } from "./errors/sdkvalidationerror.js";

export const CreateManagerResponseSetupStatus = {
  Pending: "pending",
} as const;
export type CreateManagerResponseSetupStatus = ClosedEnum<
  typeof CreateManagerResponseSetupStatus
>;

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

export const CreateManagerResponseDefinitionId = {
  CustomerAi: "customer-ai",
  CustomerKey: "customer-key",
  CustomerStorage: "customer-storage",
  CustomerRegistry: "customer-registry",
  CustomerSandbox: "customer-sandbox",
} as const;
export type CreateManagerResponseDefinitionId = ClosedEnum<
  typeof CreateManagerResponseDefinitionId
>;

export type CreateManagerResponseSourceBuiltIn = {
  type: "built-in";
  definitionId: CreateManagerResponseDefinitionId;
  version: string;
  /**
   * Unique identifier for the release.
   */
  sourceReleaseId: string;
};

export type CreateManagerResponseSourceProjectRelease = {
  type: "project-release";
  releaseChannel: string;
  /**
   * Unique identifier for the release.
   */
  releaseId: string;
  resourceId?: string | undefined;
};

export type CreateManagerResponseSourceUnion =
  | CreateManagerResponseSourceProjectRelease
  | CreateManagerResponseSourceBuiltIn;

export const CreateManagerResponseAllowedProvider = {
  AwsBedrock: "aws-bedrock",
  GcpVertex: "gcp-vertex",
  AzureFoundry: "azure-foundry",
  Anthropic: "anthropic",
  Databricks: "databricks",
  Openai: "openai",
} as const;
export type CreateManagerResponseAllowedProvider = ClosedEnum<
  typeof CreateManagerResponseAllowedProvider
>;

export const CreateManagerResponseProviderAllowlist = {
  AwsBedrock: "aws-bedrock",
  GcpVertex: "gcp-vertex",
  AzureFoundry: "azure-foundry",
  Anthropic: "anthropic",
  Databricks: "databricks",
  Openai: "openai",
} as const;
export type CreateManagerResponseProviderAllowlist = ClosedEnum<
  typeof CreateManagerResponseProviderAllowlist
>;

export const CreateManagerResponseClientApi = {
  OpenaiChat: "openai-chat",
  OpenaiResponses: "openai-responses",
  AnthropicMessages: "anthropic-messages",
} as const;
export type CreateManagerResponseClientApi = ClosedEnum<
  typeof CreateManagerResponseClientApi
>;

export type CreateManagerResponseModelRequirement = {
  publicModelId: string;
  clientApis: Array<CreateManagerResponseClientApi>;
  required: boolean;
};

export type CreateManagerResponseConfiguration = {
  allowedProviders?: Array<CreateManagerResponseAllowedProvider> | undefined;
  providerAllowlist?: Array<CreateManagerResponseProviderAllowlist> | undefined;
  modelRequirements?: Array<CreateManagerResponseModelRequirement> | undefined;
};

export type CreateManagerResponseItem = {
  item: CreateManagerResponseItemEnum;
  source:
    | CreateManagerResponseSourceProjectRelease
    | CreateManagerResponseSourceBuiltIn;
  required: boolean;
  configuration?: CreateManagerResponseConfiguration | undefined;
};

export const CreateManagerResponseEnvironmentVariableType = {
  Plain: "plain",
  Secret: "secret",
} as const;
export type CreateManagerResponseEnvironmentVariableType = ClosedEnum<
  typeof CreateManagerResponseEnvironmentVariableType
>;

export type CreateManagerResponseEnvironmentVariable = {
  name: string;
  type: CreateManagerResponseEnvironmentVariableType;
  targetResources: Array<string> | null;
};

export type CreateManagerResponseSetupConfig = {
  metadata: { [k: string]: any | null };
  policy: DeploymentSetupPolicy;
  inputValues?: { [k: string]: EncryptedStackInputValue } | undefined;
  /**
   * Immutable setup items and exact sources captured when this setup link is created.
   */
  items?: Array<CreateManagerResponseItem> | undefined;
  /**
   * Operator-pinned deployment subdomain for this setup token.
   */
  publicSubdomain?: string | undefined;
  environmentVariables: Array<CreateManagerResponseEnvironmentVariable>;
};

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

export type CreateManagerResponsePoolsAutoscale3 = {
  failureDomains?:
    | CreateManagerResponseFailureDomains6
    | 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 CreateManagerResponseFailureDomains5 = {
  /**
   * 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 CreateManagerResponseFailureDomainsUnion5 =
  | CreateManagerResponseFailureDomains5
  | any;

export type CreateManagerResponsePoolsFixed3 = {
  failureDomains?:
    | CreateManagerResponseFailureDomains5
    | 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 CreateManagerResponsePoolsUnion3 =
  | CreateManagerResponsePoolsFixed3
  | CreateManagerResponsePoolsAutoscale3;

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

export type CreateManagerResponseComputeUnion3 =
  | CreateManagerResponseCompute3
  | any;

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

export type CreateManagerResponseAws3 = {
  certificateArn: string;
};

export type CreateManagerResponseAwsUnion3 = CreateManagerResponseAws3 | any;

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

export type CreateManagerResponseAzureUnion3 =
  | CreateManagerResponseAzure3
  | any;

export type CreateManagerResponseGcp3 = {
  certificateName: string;
};

export type CreateManagerResponseGcpUnion3 = CreateManagerResponseGcp3 | any;

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

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

export type CreateManagerResponseDomainsKubernetesUnion3 =
  | CreateManagerResponseDomainsKubernetes3
  | any;

/**
 * Platform-specific certificate references for custom domains.
 */
export type CreateManagerResponseDomainsCertificate3 = {
  aws?: CreateManagerResponseAws3 | any | null | undefined;
  azure?: CreateManagerResponseAzure3 | any | null | undefined;
  gcp?: CreateManagerResponseGcp3 | any | null | undefined;
  kubernetes?: CreateManagerResponseDomainsKubernetes3 | any | null | undefined;
};

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

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

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

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

export type CreateManagerResponsePublicEndpointTargetMachineAddresses3 = {
  mode: CreateManagerResponseModeMachineAddresses3;
};

export type CreateManagerResponsePublicEndpointTargetUnion3 =
  | CreateManagerResponsePublicEndpointTargetLoadBalancer3
  | CreateManagerResponsePublicEndpointTargetMachineAddresses3
  | 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 CreateManagerResponseDomains3 = {
  /**
   * Custom domain configuration per resource ID.
   */
  customDomains?:
    | { [k: string]: CreateManagerResponseCustomDomains3 }
    | null
    | undefined;
  publicEndpointTarget?:
    | CreateManagerResponsePublicEndpointTargetLoadBalancer3
    | CreateManagerResponsePublicEndpointTargetMachineAddresses3
    | any
    | null
    | undefined;
};

export type CreateManagerResponseDomainsUnion3 =
  | CreateManagerResponseDomains3
  | 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 CreateManagerResponseExternalBindings3 = {};

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

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

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

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

export type CreateManagerResponseClusterUnion3 =
  | CreateManagerResponseCluster3
  | any;

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

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

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

export type CreateManagerResponseCertificateManagedAcmImport6 = {
  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 CreateManagerResponseCertificateTLSSecretRef6 = {
  /**
   * 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 CreateManagerResponseCertificateUnion6 =
  | CreateManagerResponseCertificateTLSSecretRef6
  | CreateManagerResponseCertificateManagedAcmImport6
  | CreateManagerResponseCertificateAwsAcmArn6
  | CreateManagerResponseCertificateManagedTLSSecret6
  | CreateManagerResponseCertificateNone6;

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

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb12 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum12;
  /**
   * 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 CreateManagerResponseProviderUnion12 =
  | CreateManagerResponseProviderAwsAlb12
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers12
  | CreateManagerResponseProviderGkeGateway12
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type CreateManagerResponseRouteGateway6 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb12
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers12
    | CreateManagerResponseProviderGkeGateway12
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb11 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum11;
  /**
   * 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 CreateManagerResponseProviderUnion11 =
  | CreateManagerResponseProviderAwsAlb11
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers11
  | CreateManagerResponseProviderGkeGateway11
  | any;

/**
 * Shared Ingress route profile values.
 */
export type CreateManagerResponseRouteIngress6 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb11
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers11
    | CreateManagerResponseProviderGkeGateway11
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type CreateManagerResponseRouteUnion6 =
  | CreateManagerResponseRouteIngress6
  | CreateManagerResponseRouteGateway6;

export type CreateManagerResponseExposureCustom3 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | CreateManagerResponseCertificateTLSSecretRef6
    | CreateManagerResponseCertificateManagedAcmImport6
    | CreateManagerResponseCertificateAwsAcmArn6
    | CreateManagerResponseCertificateManagedTLSSecret6
    | CreateManagerResponseCertificateNone6;
  /**
   * Hostname routed by the Kubernetes public endpoint.
   */
  domain: string;
  mode: CreateManagerResponseModeCustom3;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route:
    | CreateManagerResponseRouteIngress6
    | CreateManagerResponseRouteGateway6;
};

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

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

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

export type CreateManagerResponseCertificateManagedAcmImport5 = {
  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 CreateManagerResponseCertificateTLSSecretRef5 = {
  /**
   * 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 CreateManagerResponseCertificateUnion5 =
  | CreateManagerResponseCertificateTLSSecretRef5
  | CreateManagerResponseCertificateManagedAcmImport5
  | CreateManagerResponseCertificateAwsAcmArn5
  | CreateManagerResponseCertificateManagedTLSSecret5
  | CreateManagerResponseCertificateNone5;

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

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb10 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum10;
  /**
   * 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 CreateManagerResponseProviderUnion10 =
  | CreateManagerResponseProviderAwsAlb10
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers10
  | CreateManagerResponseProviderGkeGateway10
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type CreateManagerResponseRouteGateway5 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb10
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers10
    | CreateManagerResponseProviderGkeGateway10
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb9 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum9;
  /**
   * 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 CreateManagerResponseProviderUnion9 =
  | CreateManagerResponseProviderAwsAlb9
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers9
  | CreateManagerResponseProviderGkeGateway9
  | any;

/**
 * Shared Ingress route profile values.
 */
export type CreateManagerResponseRouteIngress5 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb9
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers9
    | CreateManagerResponseProviderGkeGateway9
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type CreateManagerResponseRouteUnion5 =
  | CreateManagerResponseRouteIngress5
  | CreateManagerResponseRouteGateway5;

export type CreateManagerResponseExposureGenerated3 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | CreateManagerResponseCertificateTLSSecretRef5
    | CreateManagerResponseCertificateManagedAcmImport5
    | CreateManagerResponseCertificateAwsAcmArn5
    | CreateManagerResponseCertificateManagedTLSSecret5
    | CreateManagerResponseCertificateNone5;
  mode: CreateManagerResponseModeGenerated3;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route:
    | CreateManagerResponseRouteIngress5
    | CreateManagerResponseRouteGateway5;
};

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

export type CreateManagerResponseExposureDisabled3 = {
  mode: CreateManagerResponseModeDisabled3;
};

export type CreateManagerResponseExposureUnion3 =
  | CreateManagerResponseExposureCustom3
  | CreateManagerResponseExposureGenerated3
  | CreateManagerResponseExposureDisabled3
  | 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 CreateManagerResponseKubernetes3 = {
  cluster?: CreateManagerResponseCluster3 | any | null | undefined;
  exposure?:
    | CreateManagerResponseExposureCustom3
    | CreateManagerResponseExposureGenerated3
    | CreateManagerResponseExposureDisabled3
    | any
    | null
    | undefined;
};

export type CreateManagerResponseKubernetesUnion3 =
  | CreateManagerResponseKubernetes3
  | any;

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

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

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

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

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

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

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

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

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

export type CreateManagerResponseNetworkUseDefault3 = {
  type: CreateManagerResponseTypeUseDefault3;
};

export type CreateManagerResponseNetworkUnion3 =
  | CreateManagerResponseNetworkByoVpcAws3
  | CreateManagerResponseNetworkByoVpcGcp3
  | CreateManagerResponseNetworkByoVnetAzure3
  | CreateManagerResponseNetworkUseDefault3
  | CreateManagerResponseNetworkCreate3
  | any;

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

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

/**
 * 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 CreateManagerResponseStackSettings3 = {
  compute?: CreateManagerResponseCompute3 | any | null | undefined;
  /**
   * Deployment model: how updates are delivered to the remote environment.
   */
  deploymentModel?: CreateManagerResponseDeploymentModel3 | undefined;
  domains?: CreateManagerResponseDomains3 | 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?: CreateManagerResponseExternalBindings3 | null | undefined;
  /**
   * How heartbeat health checks are handled.
   */
  heartbeats?: CreateManagerResponseHeartbeats3 | undefined;
  kubernetes?: CreateManagerResponseKubernetes3 | any | null | undefined;
  network?:
    | CreateManagerResponseNetworkByoVpcAws3
    | CreateManagerResponseNetworkByoVpcGcp3
    | CreateManagerResponseNetworkByoVnetAzure3
    | CreateManagerResponseNetworkUseDefault3
    | CreateManagerResponseNetworkCreate3
    | 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?: CreateManagerResponseTelemetry3 | undefined;
  /**
   * How updates are delivered to the deployment.
   */
  updates?: CreateManagerResponseUpdates3 | undefined;
};

export type CreateManagerResponseSetupTerraform = {
  method: "terraform";
  deploymentPortalUrl: string;
  managerUrl: string;
  providerSource: string;
  moduleSource: string;
  moduleVersion?: string | undefined;
  moduleInputs: { [k: string]: string };
  mainTf: string;
  tfvars: string;
  commands: string;
  /**
   * 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: CreateManagerResponseStackSettings3;
};

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

export type CreateManagerResponsePoolsAutoscale2 = {
  failureDomains?:
    | CreateManagerResponseFailureDomains4
    | 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 CreateManagerResponseFailureDomains3 = {
  /**
   * 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 CreateManagerResponseFailureDomainsUnion3 =
  | CreateManagerResponseFailureDomains3
  | any;

export type CreateManagerResponsePoolsFixed2 = {
  failureDomains?:
    | CreateManagerResponseFailureDomains3
    | 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 CreateManagerResponsePoolsUnion2 =
  | CreateManagerResponsePoolsFixed2
  | CreateManagerResponsePoolsAutoscale2;

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

export type CreateManagerResponseComputeUnion2 =
  | CreateManagerResponseCompute2
  | any;

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

export type CreateManagerResponseAws2 = {
  certificateArn: string;
};

export type CreateManagerResponseAwsUnion2 = CreateManagerResponseAws2 | any;

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

export type CreateManagerResponseAzureUnion2 =
  | CreateManagerResponseAzure2
  | any;

export type CreateManagerResponseGcp2 = {
  certificateName: string;
};

export type CreateManagerResponseGcpUnion2 = CreateManagerResponseGcp2 | any;

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

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

export type CreateManagerResponseDomainsKubernetesUnion2 =
  | CreateManagerResponseDomainsKubernetes2
  | any;

/**
 * Platform-specific certificate references for custom domains.
 */
export type CreateManagerResponseDomainsCertificate2 = {
  aws?: CreateManagerResponseAws2 | any | null | undefined;
  azure?: CreateManagerResponseAzure2 | any | null | undefined;
  gcp?: CreateManagerResponseGcp2 | any | null | undefined;
  kubernetes?: CreateManagerResponseDomainsKubernetes2 | any | null | undefined;
};

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

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

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

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

export type CreateManagerResponsePublicEndpointTargetMachineAddresses2 = {
  mode: CreateManagerResponseModeMachineAddresses2;
};

export type CreateManagerResponsePublicEndpointTargetUnion2 =
  | CreateManagerResponsePublicEndpointTargetLoadBalancer2
  | CreateManagerResponsePublicEndpointTargetMachineAddresses2
  | 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 CreateManagerResponseDomains2 = {
  /**
   * Custom domain configuration per resource ID.
   */
  customDomains?:
    | { [k: string]: CreateManagerResponseCustomDomains2 }
    | null
    | undefined;
  publicEndpointTarget?:
    | CreateManagerResponsePublicEndpointTargetLoadBalancer2
    | CreateManagerResponsePublicEndpointTargetMachineAddresses2
    | any
    | null
    | undefined;
};

export type CreateManagerResponseDomainsUnion2 =
  | CreateManagerResponseDomains2
  | 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 CreateManagerResponseExternalBindings2 = {};

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

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

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

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

export type CreateManagerResponseClusterUnion2 =
  | CreateManagerResponseCluster2
  | any;

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

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

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

export type CreateManagerResponseCertificateManagedAcmImport4 = {
  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 CreateManagerResponseCertificateTLSSecretRef4 = {
  /**
   * 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 CreateManagerResponseCertificateUnion4 =
  | CreateManagerResponseCertificateTLSSecretRef4
  | CreateManagerResponseCertificateManagedAcmImport4
  | CreateManagerResponseCertificateAwsAcmArn4
  | CreateManagerResponseCertificateManagedTLSSecret4
  | CreateManagerResponseCertificateNone4;

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

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb8 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum8;
  /**
   * 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 CreateManagerResponseProviderUnion8 =
  | CreateManagerResponseProviderAwsAlb8
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers8
  | CreateManagerResponseProviderGkeGateway8
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type CreateManagerResponseRouteGateway4 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb8
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers8
    | CreateManagerResponseProviderGkeGateway8
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb7 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum7;
  /**
   * 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 CreateManagerResponseProviderUnion7 =
  | CreateManagerResponseProviderAwsAlb7
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers7
  | CreateManagerResponseProviderGkeGateway7
  | any;

/**
 * Shared Ingress route profile values.
 */
export type CreateManagerResponseRouteIngress4 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb7
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers7
    | CreateManagerResponseProviderGkeGateway7
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type CreateManagerResponseRouteUnion4 =
  | CreateManagerResponseRouteIngress4
  | CreateManagerResponseRouteGateway4;

export type CreateManagerResponseExposureCustom2 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | CreateManagerResponseCertificateTLSSecretRef4
    | CreateManagerResponseCertificateManagedAcmImport4
    | CreateManagerResponseCertificateAwsAcmArn4
    | CreateManagerResponseCertificateManagedTLSSecret4
    | CreateManagerResponseCertificateNone4;
  /**
   * Hostname routed by the Kubernetes public endpoint.
   */
  domain: string;
  mode: CreateManagerResponseModeCustom2;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route:
    | CreateManagerResponseRouteIngress4
    | CreateManagerResponseRouteGateway4;
};

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

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

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

export type CreateManagerResponseCertificateManagedAcmImport3 = {
  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 CreateManagerResponseCertificateTLSSecretRef3 = {
  /**
   * 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 CreateManagerResponseCertificateUnion3 =
  | CreateManagerResponseCertificateTLSSecretRef3
  | CreateManagerResponseCertificateManagedAcmImport3
  | CreateManagerResponseCertificateAwsAcmArn3
  | CreateManagerResponseCertificateManagedTLSSecret3
  | CreateManagerResponseCertificateNone3;

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

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb6 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum6;
  /**
   * 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 CreateManagerResponseProviderUnion6 =
  | CreateManagerResponseProviderAwsAlb6
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers6
  | CreateManagerResponseProviderGkeGateway6
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type CreateManagerResponseRouteGateway3 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb6
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers6
    | CreateManagerResponseProviderGkeGateway6
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb5 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum5;
  /**
   * 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 CreateManagerResponseProviderUnion5 =
  | CreateManagerResponseProviderAwsAlb5
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers5
  | CreateManagerResponseProviderGkeGateway5
  | any;

/**
 * Shared Ingress route profile values.
 */
export type CreateManagerResponseRouteIngress3 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb5
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers5
    | CreateManagerResponseProviderGkeGateway5
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type CreateManagerResponseRouteUnion3 =
  | CreateManagerResponseRouteIngress3
  | CreateManagerResponseRouteGateway3;

export type CreateManagerResponseExposureGenerated2 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | CreateManagerResponseCertificateTLSSecretRef3
    | CreateManagerResponseCertificateManagedAcmImport3
    | CreateManagerResponseCertificateAwsAcmArn3
    | CreateManagerResponseCertificateManagedTLSSecret3
    | CreateManagerResponseCertificateNone3;
  mode: CreateManagerResponseModeGenerated2;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route:
    | CreateManagerResponseRouteIngress3
    | CreateManagerResponseRouteGateway3;
};

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

export type CreateManagerResponseExposureDisabled2 = {
  mode: CreateManagerResponseModeDisabled2;
};

export type CreateManagerResponseExposureUnion2 =
  | CreateManagerResponseExposureCustom2
  | CreateManagerResponseExposureGenerated2
  | CreateManagerResponseExposureDisabled2
  | 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 CreateManagerResponseKubernetes2 = {
  cluster?: CreateManagerResponseCluster2 | any | null | undefined;
  exposure?:
    | CreateManagerResponseExposureCustom2
    | CreateManagerResponseExposureGenerated2
    | CreateManagerResponseExposureDisabled2
    | any
    | null
    | undefined;
};

export type CreateManagerResponseKubernetesUnion2 =
  | CreateManagerResponseKubernetes2
  | any;

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

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

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

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

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

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

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

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

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

export type CreateManagerResponseNetworkUseDefault2 = {
  type: CreateManagerResponseTypeUseDefault2;
};

export type CreateManagerResponseNetworkUnion2 =
  | CreateManagerResponseNetworkByoVpcAws2
  | CreateManagerResponseNetworkByoVpcGcp2
  | CreateManagerResponseNetworkByoVnetAzure2
  | CreateManagerResponseNetworkUseDefault2
  | CreateManagerResponseNetworkCreate2
  | any;

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

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

/**
 * 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 CreateManagerResponseStackSettings2 = {
  compute?: CreateManagerResponseCompute2 | any | null | undefined;
  /**
   * Deployment model: how updates are delivered to the remote environment.
   */
  deploymentModel?: CreateManagerResponseDeploymentModel2 | undefined;
  domains?: CreateManagerResponseDomains2 | 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?: CreateManagerResponseExternalBindings2 | null | undefined;
  /**
   * How heartbeat health checks are handled.
   */
  heartbeats?: CreateManagerResponseHeartbeats2 | undefined;
  kubernetes?: CreateManagerResponseKubernetes2 | any | null | undefined;
  network?:
    | CreateManagerResponseNetworkByoVpcAws2
    | CreateManagerResponseNetworkByoVpcGcp2
    | CreateManagerResponseNetworkByoVnetAzure2
    | CreateManagerResponseNetworkUseDefault2
    | CreateManagerResponseNetworkCreate2
    | 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?: CreateManagerResponseTelemetry2 | undefined;
  /**
   * How updates are delivered to the deployment.
   */
  updates?: CreateManagerResponseUpdates2 | undefined;
};

export type CreateManagerResponseSetupGoogleOauth = {
  method: "google-oauth";
  deploymentPortalUrl: string;
  managerUrl: string;
  oauthStartUrl: string;
  region: string;
  /**
   * 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: CreateManagerResponseStackSettings2;
};

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

export type CreateManagerResponsePoolsAutoscale1 = {
  failureDomains?:
    | CreateManagerResponseFailureDomains2
    | 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 CreateManagerResponseFailureDomains1 = {
  /**
   * 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 CreateManagerResponseFailureDomainsUnion1 =
  | CreateManagerResponseFailureDomains1
  | any;

export type CreateManagerResponsePoolsFixed1 = {
  failureDomains?:
    | CreateManagerResponseFailureDomains1
    | 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 CreateManagerResponsePoolsUnion1 =
  | CreateManagerResponsePoolsFixed1
  | CreateManagerResponsePoolsAutoscale1;

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

export type CreateManagerResponseComputeUnion1 =
  | CreateManagerResponseCompute1
  | any;

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

export type CreateManagerResponseAws1 = {
  certificateArn: string;
};

export type CreateManagerResponseAwsUnion1 = CreateManagerResponseAws1 | any;

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

export type CreateManagerResponseAzureUnion1 =
  | CreateManagerResponseAzure1
  | any;

export type CreateManagerResponseGcp1 = {
  certificateName: string;
};

export type CreateManagerResponseGcpUnion1 = CreateManagerResponseGcp1 | any;

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

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

export type CreateManagerResponseDomainsKubernetesUnion1 =
  | CreateManagerResponseDomainsKubernetes1
  | any;

/**
 * Platform-specific certificate references for custom domains.
 */
export type CreateManagerResponseDomainsCertificate1 = {
  aws?: CreateManagerResponseAws1 | any | null | undefined;
  azure?: CreateManagerResponseAzure1 | any | null | undefined;
  gcp?: CreateManagerResponseGcp1 | any | null | undefined;
  kubernetes?: CreateManagerResponseDomainsKubernetes1 | any | null | undefined;
};

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

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

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

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

export type CreateManagerResponsePublicEndpointTargetMachineAddresses1 = {
  mode: CreateManagerResponseModeMachineAddresses1;
};

export type CreateManagerResponsePublicEndpointTargetUnion1 =
  | CreateManagerResponsePublicEndpointTargetLoadBalancer1
  | CreateManagerResponsePublicEndpointTargetMachineAddresses1
  | 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 CreateManagerResponseDomains1 = {
  /**
   * Custom domain configuration per resource ID.
   */
  customDomains?:
    | { [k: string]: CreateManagerResponseCustomDomains1 }
    | null
    | undefined;
  publicEndpointTarget?:
    | CreateManagerResponsePublicEndpointTargetLoadBalancer1
    | CreateManagerResponsePublicEndpointTargetMachineAddresses1
    | any
    | null
    | undefined;
};

export type CreateManagerResponseDomainsUnion1 =
  | CreateManagerResponseDomains1
  | 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 CreateManagerResponseExternalBindings1 = {};

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

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

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

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

export type CreateManagerResponseClusterUnion1 =
  | CreateManagerResponseCluster1
  | any;

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

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

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

export type CreateManagerResponseCertificateManagedAcmImport2 = {
  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 CreateManagerResponseCertificateTLSSecretRef2 = {
  /**
   * 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 CreateManagerResponseCertificateUnion2 =
  | CreateManagerResponseCertificateTLSSecretRef2
  | CreateManagerResponseCertificateManagedAcmImport2
  | CreateManagerResponseCertificateAwsAcmArn2
  | CreateManagerResponseCertificateManagedTLSSecret2
  | CreateManagerResponseCertificateNone2;

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

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb4 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum4;
  /**
   * 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 CreateManagerResponseProviderUnion4 =
  | CreateManagerResponseProviderAwsAlb4
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers4
  | CreateManagerResponseProviderGkeGateway4
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type CreateManagerResponseRouteGateway2 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb4
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers4
    | CreateManagerResponseProviderGkeGateway4
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb3 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum3;
  /**
   * 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 CreateManagerResponseProviderUnion3 =
  | CreateManagerResponseProviderAwsAlb3
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers3
  | CreateManagerResponseProviderGkeGateway3
  | any;

/**
 * Shared Ingress route profile values.
 */
export type CreateManagerResponseRouteIngress2 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb3
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers3
    | CreateManagerResponseProviderGkeGateway3
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type CreateManagerResponseRouteUnion2 =
  | CreateManagerResponseRouteIngress2
  | CreateManagerResponseRouteGateway2;

export type CreateManagerResponseExposureCustom1 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | CreateManagerResponseCertificateTLSSecretRef2
    | CreateManagerResponseCertificateManagedAcmImport2
    | CreateManagerResponseCertificateAwsAcmArn2
    | CreateManagerResponseCertificateManagedTLSSecret2
    | CreateManagerResponseCertificateNone2;
  /**
   * Hostname routed by the Kubernetes public endpoint.
   */
  domain: string;
  mode: CreateManagerResponseModeCustom1;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route:
    | CreateManagerResponseRouteIngress2
    | CreateManagerResponseRouteGateway2;
};

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

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

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

export type CreateManagerResponseCertificateManagedAcmImport1 = {
  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 CreateManagerResponseCertificateTLSSecretRef1 = {
  /**
   * 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 CreateManagerResponseCertificateUnion1 =
  | CreateManagerResponseCertificateTLSSecretRef1
  | CreateManagerResponseCertificateManagedAcmImport1
  | CreateManagerResponseCertificateAwsAcmArn1
  | CreateManagerResponseCertificateManagedTLSSecret1
  | CreateManagerResponseCertificateNone1;

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

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb2 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum2;
  /**
   * 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 CreateManagerResponseProviderUnion2 =
  | CreateManagerResponseProviderAwsAlb2
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers2
  | CreateManagerResponseProviderGkeGateway2
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type CreateManagerResponseRouteGateway1 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb2
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers2
    | CreateManagerResponseProviderGkeGateway2
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type CreateManagerResponseProviderAwsAlb1 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: CreateManagerResponseProviderAwsAlbEnum1;
  /**
   * 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 CreateManagerResponseProviderUnion1 =
  | CreateManagerResponseProviderAwsAlb1
  | CreateManagerResponseProviderAzureApplicationGatewayForContainers1
  | CreateManagerResponseProviderGkeGateway1
  | any;

/**
 * Shared Ingress route profile values.
 */
export type CreateManagerResponseRouteIngress1 = {
  /**
   * 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?:
    | CreateManagerResponseProviderAwsAlb1
    | CreateManagerResponseProviderAzureApplicationGatewayForContainers1
    | CreateManagerResponseProviderGkeGateway1
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type CreateManagerResponseRouteUnion1 =
  | CreateManagerResponseRouteIngress1
  | CreateManagerResponseRouteGateway1;

export type CreateManagerResponseExposureGenerated1 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | CreateManagerResponseCertificateTLSSecretRef1
    | CreateManagerResponseCertificateManagedAcmImport1
    | CreateManagerResponseCertificateAwsAcmArn1
    | CreateManagerResponseCertificateManagedTLSSecret1
    | CreateManagerResponseCertificateNone1;
  mode: CreateManagerResponseModeGenerated1;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route:
    | CreateManagerResponseRouteIngress1
    | CreateManagerResponseRouteGateway1;
};

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

export type CreateManagerResponseExposureDisabled1 = {
  mode: CreateManagerResponseModeDisabled1;
};

export type CreateManagerResponseExposureUnion1 =
  | CreateManagerResponseExposureCustom1
  | CreateManagerResponseExposureGenerated1
  | CreateManagerResponseExposureDisabled1
  | 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 CreateManagerResponseKubernetes1 = {
  cluster?: CreateManagerResponseCluster1 | any | null | undefined;
  exposure?:
    | CreateManagerResponseExposureCustom1
    | CreateManagerResponseExposureGenerated1
    | CreateManagerResponseExposureDisabled1
    | any
    | null
    | undefined;
};

export type CreateManagerResponseKubernetesUnion1 =
  | CreateManagerResponseKubernetes1
  | any;

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

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

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

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

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

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

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

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

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

export type CreateManagerResponseNetworkUseDefault1 = {
  type: CreateManagerResponseTypeUseDefault1;
};

export type CreateManagerResponseNetworkUnion1 =
  | CreateManagerResponseNetworkByoVpcAws1
  | CreateManagerResponseNetworkByoVpcGcp1
  | CreateManagerResponseNetworkByoVnetAzure1
  | CreateManagerResponseNetworkUseDefault1
  | CreateManagerResponseNetworkCreate1
  | any;

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

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

/**
 * 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 CreateManagerResponseStackSettings1 = {
  compute?: CreateManagerResponseCompute1 | any | null | undefined;
  /**
   * Deployment model: how updates are delivered to the remote environment.
   */
  deploymentModel?: CreateManagerResponseDeploymentModel1 | undefined;
  domains?: CreateManagerResponseDomains1 | 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?: CreateManagerResponseExternalBindings1 | null | undefined;
  /**
   * How heartbeat health checks are handled.
   */
  heartbeats?: CreateManagerResponseHeartbeats1 | undefined;
  kubernetes?: CreateManagerResponseKubernetes1 | any | null | undefined;
  network?:
    | CreateManagerResponseNetworkByoVpcAws1
    | CreateManagerResponseNetworkByoVpcGcp1
    | CreateManagerResponseNetworkByoVnetAzure1
    | CreateManagerResponseNetworkUseDefault1
    | CreateManagerResponseNetworkCreate1
    | 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?: CreateManagerResponseTelemetry1 | undefined;
  /**
   * How updates are delivered to the deployment.
   */
  updates?: CreateManagerResponseUpdates1 | undefined;
};

export type CreateManagerResponseSetupCloudformation = {
  method: "cloudformation";
  deploymentPortalUrl: string;
  launchUrl: string;
  templateUrl: string;
  stackName: string;
  region: string;
  /**
   * 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: CreateManagerResponseStackSettings1;
};

export type CreateManagerResponseSetupUnion =
  | CreateManagerResponseSetupCloudformation
  | CreateManagerResponseSetupGoogleOauth
  | CreateManagerResponseSetupTerraform;

export type CreateManagerResponse = {
  managerId: string;
  setupStatus: CreateManagerResponseSetupStatus;
  setupToken: string;
  setupTokenId: string;
  deploymentLink: string;
  setupConfig: CreateManagerResponseSetupConfig;
  setup:
    | CreateManagerResponseSetupCloudformation
    | CreateManagerResponseSetupGoogleOauth
    | CreateManagerResponseSetupTerraform;
};

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

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

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

/** @internal */
export const CreateManagerResponseSourceBuiltIn$inboundSchema: z.ZodType<
  CreateManagerResponseSourceBuiltIn,
  unknown
> = z.object({
  type: z.literal("built-in"),
  definitionId: CreateManagerResponseDefinitionId$inboundSchema,
  version: z.string(),
  sourceReleaseId: z.string(),
});

export function createManagerResponseSourceBuiltInFromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseSourceBuiltIn, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseSourceBuiltIn$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseSourceBuiltIn' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseSourceProjectRelease$inboundSchema: z.ZodType<
  CreateManagerResponseSourceProjectRelease,
  unknown
> = z.object({
  type: z.literal("project-release"),
  releaseChannel: z.string(),
  releaseId: z.string(),
  resourceId: z.string().optional(),
});

export function createManagerResponseSourceProjectReleaseFromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseSourceProjectRelease,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseSourceProjectRelease$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseSourceProjectRelease' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseSourceUnion$inboundSchema: z.ZodType<
  CreateManagerResponseSourceUnion,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseSourceProjectRelease$inboundSchema),
  z.lazy(() => CreateManagerResponseSourceBuiltIn$inboundSchema),
]);

export function createManagerResponseSourceUnionFromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseSourceUnion, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseSourceUnion$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseSourceUnion' from JSON`,
  );
}

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

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

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

/** @internal */
export const CreateManagerResponseModelRequirement$inboundSchema: z.ZodType<
  CreateManagerResponseModelRequirement,
  unknown
> = z.object({
  publicModelId: z.string(),
  clientApis: z.array(CreateManagerResponseClientApi$inboundSchema),
  required: z.boolean(),
});

export function createManagerResponseModelRequirementFromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseModelRequirement, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseModelRequirement$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseModelRequirement' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseConfiguration$inboundSchema: z.ZodType<
  CreateManagerResponseConfiguration,
  unknown
> = z.object({
  allowedProviders: z.array(CreateManagerResponseAllowedProvider$inboundSchema)
    .optional(),
  providerAllowlist: z.array(
    CreateManagerResponseProviderAllowlist$inboundSchema,
  ).optional(),
  modelRequirements: z.array(
    z.lazy(() => CreateManagerResponseModelRequirement$inboundSchema),
  ).optional(),
});

export function createManagerResponseConfigurationFromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseConfiguration, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseConfiguration$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseConfiguration' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseItem$inboundSchema: z.ZodType<
  CreateManagerResponseItem,
  unknown
> = z.object({
  item: CreateManagerResponseItemEnum$inboundSchema,
  source: z.union([
    z.lazy(() => CreateManagerResponseSourceProjectRelease$inboundSchema),
    z.lazy(() => CreateManagerResponseSourceBuiltIn$inboundSchema),
  ]),
  required: z.boolean(),
  configuration: z.lazy(() => CreateManagerResponseConfiguration$inboundSchema)
    .optional(),
});

export function createManagerResponseItemFromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseItem, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseItem$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseItem' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseEnvironmentVariable$inboundSchema: z.ZodType<
  CreateManagerResponseEnvironmentVariable,
  unknown
> = z.object({
  name: z.string(),
  type: CreateManagerResponseEnvironmentVariableType$inboundSchema,
  targetResources: z.nullable(z.array(z.string())),
});

export function createManagerResponseEnvironmentVariableFromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseEnvironmentVariable,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseEnvironmentVariable$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseEnvironmentVariable' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseSetupConfig$inboundSchema: z.ZodType<
  CreateManagerResponseSetupConfig,
  unknown
> = z.object({
  metadata: z.record(z.string(), z.nullable(z.any())),
  policy: DeploymentSetupPolicy$inboundSchema,
  inputValues: z.record(z.string(), EncryptedStackInputValue$inboundSchema)
    .optional(),
  items: z.array(z.lazy(() => CreateManagerResponseItem$inboundSchema))
    .optional(),
  publicSubdomain: z.string().optional(),
  environmentVariables: z.array(
    z.lazy(() => CreateManagerResponseEnvironmentVariable$inboundSchema),
  ),
});

export function createManagerResponseSetupConfigFromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseSetupConfig, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseSetupConfig$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseSetupConfig' from JSON`,
  );
}

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

export function createManagerResponseFailureDomains6FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseFailureDomains6, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomains6$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseFailureDomains6' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseFailureDomainsUnion6$inboundSchema: z.ZodType<
  CreateManagerResponseFailureDomainsUnion6,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseFailureDomains6$inboundSchema),
  z.any(),
]);

export function createManagerResponseFailureDomainsUnion6FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseFailureDomainsUnion6,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomainsUnion6$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseFailureDomainsUnion6' from JSON`,
  );
}

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

export function createManagerResponsePoolsAutoscale3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponsePoolsAutoscale3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePoolsAutoscale3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePoolsAutoscale3' from JSON`,
  );
}

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

export function createManagerResponseFailureDomains5FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseFailureDomains5, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomains5$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseFailureDomains5' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseFailureDomainsUnion5$inboundSchema: z.ZodType<
  CreateManagerResponseFailureDomainsUnion5,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseFailureDomains5$inboundSchema),
  z.any(),
]);

export function createManagerResponseFailureDomainsUnion5FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseFailureDomainsUnion5,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomainsUnion5$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseFailureDomainsUnion5' from JSON`,
  );
}

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

export function createManagerResponsePoolsFixed3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponsePoolsFixed3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponsePoolsFixed3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePoolsFixed3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponsePoolsUnion3$inboundSchema: z.ZodType<
  CreateManagerResponsePoolsUnion3,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponsePoolsFixed3$inboundSchema),
  z.lazy(() => CreateManagerResponsePoolsAutoscale3$inboundSchema),
]);

export function createManagerResponsePoolsUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponsePoolsUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponsePoolsUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePoolsUnion3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCompute3$inboundSchema: z.ZodType<
  CreateManagerResponseCompute3,
  unknown
> = z.object({
  pools: z.record(
    z.string(),
    z.union([
      z.lazy(() => CreateManagerResponsePoolsFixed3$inboundSchema),
      z.lazy(() => CreateManagerResponsePoolsAutoscale3$inboundSchema),
    ]),
  ).optional(),
});

export function createManagerResponseCompute3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCompute3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCompute3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCompute3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseComputeUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseComputeUnion3,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCompute3$inboundSchema),
  z.any(),
]);

export function createManagerResponseComputeUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseComputeUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseComputeUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseComputeUnion3' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseAws3$inboundSchema: z.ZodType<
  CreateManagerResponseAws3,
  unknown
> = z.object({
  certificateArn: z.string(),
});

export function createManagerResponseAws3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAws3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAws3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAws3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseAwsUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseAwsUnion3,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseAws3$inboundSchema), z.any()]);

export function createManagerResponseAwsUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAwsUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAwsUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAwsUnion3' from JSON`,
  );
}

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

export function createManagerResponseAzure3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAzure3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAzure3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAzure3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseAzureUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseAzureUnion3,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseAzure3$inboundSchema), z.any()]);

export function createManagerResponseAzureUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAzureUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAzureUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAzureUnion3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseGcp3$inboundSchema: z.ZodType<
  CreateManagerResponseGcp3,
  unknown
> = z.object({
  certificateName: z.string(),
});

export function createManagerResponseGcp3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseGcp3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseGcp3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseGcp3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseGcpUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseGcpUnion3,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseGcp3$inboundSchema), z.any()]);

export function createManagerResponseGcpUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseGcpUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseGcpUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseGcpUnion3' from JSON`,
  );
}

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

export function createManagerResponseTlsSecretRef3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseTlsSecretRef3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseTlsSecretRef3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseTlsSecretRef3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsKubernetes3$inboundSchema: z.ZodType<
  CreateManagerResponseDomainsKubernetes3,
  unknown
> = z.object({
  tlsSecretRef: z.lazy(() => CreateManagerResponseTlsSecretRef3$inboundSchema),
});

export function createManagerResponseDomainsKubernetes3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseDomainsKubernetes3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsKubernetes3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseDomainsKubernetes3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsKubernetesUnion3$inboundSchema:
  z.ZodType<CreateManagerResponseDomainsKubernetesUnion3, unknown> = z.union([
    z.lazy(() => CreateManagerResponseDomainsKubernetes3$inboundSchema),
    z.any(),
  ]);

export function createManagerResponseDomainsKubernetesUnion3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseDomainsKubernetesUnion3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsKubernetesUnion3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseDomainsKubernetesUnion3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsCertificate3$inboundSchema: z.ZodType<
  CreateManagerResponseDomainsCertificate3,
  unknown
> = z.object({
  aws: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseAws3$inboundSchema), z.any()]),
  ).optional(),
  azure: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseAzure3$inboundSchema), z.any()]),
  ).optional(),
  gcp: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseGcp3$inboundSchema), z.any()]),
  ).optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseDomainsKubernetes3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

export function createManagerResponseDomainsCertificate3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseDomainsCertificate3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsCertificate3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseDomainsCertificate3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCustomDomains3$inboundSchema: z.ZodType<
  CreateManagerResponseCustomDomains3,
  unknown
> = z.object({
  certificate: z.lazy(() =>
    CreateManagerResponseDomainsCertificate3$inboundSchema
  ),
  domain: z.string(),
});

export function createManagerResponseCustomDomains3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCustomDomains3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCustomDomains3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCustomDomains3' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponsePublicEndpointTargetLoadBalancer3$inboundSchema:
  z.ZodType<CreateManagerResponsePublicEndpointTargetLoadBalancer3, unknown> = z
    .object({
      cnameTarget: z.string(),
      mode: CreateManagerResponseModeLoadBalancer3$inboundSchema,
    });

export function createManagerResponsePublicEndpointTargetLoadBalancer3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponsePublicEndpointTargetLoadBalancer3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePublicEndpointTargetLoadBalancer3$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePublicEndpointTargetLoadBalancer3' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponsePublicEndpointTargetMachineAddresses3$inboundSchema:
  z.ZodType<
    CreateManagerResponsePublicEndpointTargetMachineAddresses3,
    unknown
  > = z.object({
    mode: CreateManagerResponseModeMachineAddresses3$inboundSchema,
  });

export function createManagerResponsePublicEndpointTargetMachineAddresses3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponsePublicEndpointTargetMachineAddresses3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePublicEndpointTargetMachineAddresses3$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePublicEndpointTargetMachineAddresses3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponsePublicEndpointTargetUnion3$inboundSchema:
  z.ZodType<CreateManagerResponsePublicEndpointTargetUnion3, unknown> = z.union(
    [
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetLoadBalancer3$inboundSchema
      ),
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetMachineAddresses3$inboundSchema
      ),
      z.any(),
    ],
  );

export function createManagerResponsePublicEndpointTargetUnion3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponsePublicEndpointTargetUnion3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePublicEndpointTargetUnion3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponsePublicEndpointTargetUnion3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomains3$inboundSchema: z.ZodType<
  CreateManagerResponseDomains3,
  unknown
> = z.object({
  customDomains: z.nullable(
    z.record(
      z.string(),
      z.lazy(() => CreateManagerResponseCustomDomains3$inboundSchema),
    ),
  ).optional(),
  publicEndpointTarget: z.nullable(
    z.union([
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetLoadBalancer3$inboundSchema
      ),
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetMachineAddresses3$inboundSchema
      ),
      z.any(),
    ]),
  ).optional(),
});

export function createManagerResponseDomains3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseDomains3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseDomains3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseDomains3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseDomainsUnion3,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseDomains3$inboundSchema),
  z.any(),
]);

export function createManagerResponseDomainsUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseDomainsUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseDomainsUnion3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExternalBindings3$inboundSchema: z.ZodType<
  CreateManagerResponseExternalBindings3,
  unknown
> = z.object({});

export function createManagerResponseExternalBindings3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExternalBindings3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExternalBindings3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExternalBindings3' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseCloud3$inboundSchema: z.ZodType<
  CreateManagerResponseCloud3,
  unknown
> = z.object({
  accountId: z.nullable(z.string()).optional(),
  clusterId: z.nullable(z.string()).optional(),
  clusterName: z.nullable(z.string()).optional(),
  projectId: z.nullable(z.string()).optional(),
  region: z.nullable(z.string()).optional(),
  resourceGroup: z.nullable(z.string()).optional(),
  subscriptionId: z.nullable(z.string()).optional(),
});

export function createManagerResponseCloud3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCloud3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCloud3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCloud3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCloudUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseCloudUnion3,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseCloud3$inboundSchema), z.any()]);

export function createManagerResponseCloudUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCloudUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCloudUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCloudUnion3' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseCluster3$inboundSchema: z.ZodType<
  CreateManagerResponseCluster3,
  unknown
> = z.object({
  cloud: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseCloud3$inboundSchema), z.any()]),
  ).optional(),
  namespace: z.nullable(z.string()).optional(),
  ownership: CreateManagerResponseOwnership3$inboundSchema,
});

export function createManagerResponseCluster3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCluster3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCluster3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCluster3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseClusterUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseClusterUnion3,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCluster3$inboundSchema),
  z.any(),
]);

export function createManagerResponseClusterUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseClusterUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseClusterUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseClusterUnion3' from JSON`,
  );
}

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

export function createManagerResponseCertificateNone6FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateNone6, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateNone6$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateNone6' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedTLSSecret6FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedTLSSecret6,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedTLSSecret6$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedTLSSecret6' from JSON`,
  );
}

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

export function createManagerResponseCertificateAwsAcmArn6FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateAwsAcmArn6,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateAwsAcmArn6$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateAwsAcmArn6' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedAcmImport6FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedAcmImport6,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedAcmImport6$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedAcmImport6' from JSON`,
  );
}

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

export function createManagerResponseCertificateTLSSecretRef6FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateTLSSecretRef6,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateTLSSecretRef6$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateTLSSecretRef6' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCertificateUnion6$inboundSchema: z.ZodType<
  CreateManagerResponseCertificateUnion6,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCertificateTLSSecretRef6$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedAcmImport6$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateAwsAcmArn6$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedTLSSecret6$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateNone6$inboundSchema),
]);

export function createManagerResponseCertificateUnion6FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateUnion6, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateUnion6$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateUnion6' from JSON`,
  );
}

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

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers12$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers12,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum12$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers12FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers12,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers12$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers12' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway12$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway12,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum12$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway12FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway12,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway12$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway12' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb12$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb12,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum12$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb12FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb12, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb12$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb12' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion12$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion12,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb12$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers12$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway12$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion12FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion12, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion12$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion12' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteGateway6$inboundSchema: z.ZodType<
  CreateManagerResponseRouteGateway6,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  gatewayClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  listenerPort: z.int(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb12$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers12$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway12$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

export function createManagerResponseRouteGateway6FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteGateway6, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteGateway6$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteGateway6' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers11$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers11,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum11$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers11FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers11,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers11$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers11' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway11$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway11,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum11$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway11FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway11,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway11$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway11' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb11$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb11,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum11$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb11FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb11, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb11$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb11' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion11$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion11,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb11$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers11$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway11$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion11FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion11, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion11$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion11' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteIngress6$inboundSchema: z.ZodType<
  CreateManagerResponseRouteIngress6,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  ingressClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb11$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers11$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway11$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

export function createManagerResponseRouteIngress6FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteIngress6, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteIngress6$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteIngress6' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteUnion6$inboundSchema: z.ZodType<
  CreateManagerResponseRouteUnion6,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseRouteIngress6$inboundSchema),
  z.lazy(() => CreateManagerResponseRouteGateway6$inboundSchema),
]);

export function createManagerResponseRouteUnion6FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteUnion6, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseRouteUnion6$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteUnion6' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExposureCustom3$inboundSchema: z.ZodType<
  CreateManagerResponseExposureCustom3,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => CreateManagerResponseCertificateTLSSecretRef6$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedAcmImport6$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateAwsAcmArn6$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedTLSSecret6$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateNone6$inboundSchema),
  ]),
  domain: z.string(),
  mode: CreateManagerResponseModeCustom3$inboundSchema,
  route: z.union([
    z.lazy(() => CreateManagerResponseRouteIngress6$inboundSchema),
    z.lazy(() => CreateManagerResponseRouteGateway6$inboundSchema),
  ]),
});

export function createManagerResponseExposureCustom3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExposureCustom3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureCustom3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExposureCustom3' from JSON`,
  );
}

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

export function createManagerResponseCertificateNone5FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateNone5, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateNone5$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateNone5' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedTLSSecret5FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedTLSSecret5,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedTLSSecret5$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedTLSSecret5' from JSON`,
  );
}

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

export function createManagerResponseCertificateAwsAcmArn5FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateAwsAcmArn5,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateAwsAcmArn5$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateAwsAcmArn5' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedAcmImport5FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedAcmImport5,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedAcmImport5$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedAcmImport5' from JSON`,
  );
}

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

export function createManagerResponseCertificateTLSSecretRef5FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateTLSSecretRef5,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateTLSSecretRef5$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateTLSSecretRef5' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCertificateUnion5$inboundSchema: z.ZodType<
  CreateManagerResponseCertificateUnion5,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCertificateTLSSecretRef5$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedAcmImport5$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateAwsAcmArn5$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedTLSSecret5$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateNone5$inboundSchema),
]);

export function createManagerResponseCertificateUnion5FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateUnion5, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateUnion5$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateUnion5' from JSON`,
  );
}

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

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers10$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers10,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum10$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers10FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers10,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers10$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers10' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway10$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway10,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum10$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway10FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway10,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway10$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway10' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb10$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb10,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum10$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb10FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb10, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb10$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb10' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion10$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion10,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb10$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers10$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway10$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion10FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion10, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion10$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion10' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteGateway5$inboundSchema: z.ZodType<
  CreateManagerResponseRouteGateway5,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  gatewayClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  listenerPort: z.int(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb10$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers10$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway10$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

export function createManagerResponseRouteGateway5FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteGateway5, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteGateway5$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteGateway5' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers9$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers9,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum9$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers9FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers9,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers9$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers9' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway9$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway9,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum9$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway9FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway9,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway9$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway9' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb9$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb9,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum9$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb9FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb9, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb9$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb9' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion9$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion9,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb9$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers9$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway9$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion9FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion9, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion9$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion9' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteIngress5$inboundSchema: z.ZodType<
  CreateManagerResponseRouteIngress5,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  ingressClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb9$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers9$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway9$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

export function createManagerResponseRouteIngress5FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteIngress5, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteIngress5$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteIngress5' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteUnion5$inboundSchema: z.ZodType<
  CreateManagerResponseRouteUnion5,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseRouteIngress5$inboundSchema),
  z.lazy(() => CreateManagerResponseRouteGateway5$inboundSchema),
]);

export function createManagerResponseRouteUnion5FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteUnion5, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseRouteUnion5$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteUnion5' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExposureGenerated3$inboundSchema: z.ZodType<
  CreateManagerResponseExposureGenerated3,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => CreateManagerResponseCertificateTLSSecretRef5$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedAcmImport5$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateAwsAcmArn5$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedTLSSecret5$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateNone5$inboundSchema),
  ]),
  mode: CreateManagerResponseModeGenerated3$inboundSchema,
  route: z.union([
    z.lazy(() => CreateManagerResponseRouteIngress5$inboundSchema),
    z.lazy(() => CreateManagerResponseRouteGateway5$inboundSchema),
  ]),
});

export function createManagerResponseExposureGenerated3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseExposureGenerated3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureGenerated3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseExposureGenerated3' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseExposureDisabled3$inboundSchema: z.ZodType<
  CreateManagerResponseExposureDisabled3,
  unknown
> = z.object({
  mode: CreateManagerResponseModeDisabled3$inboundSchema,
});

export function createManagerResponseExposureDisabled3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExposureDisabled3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureDisabled3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExposureDisabled3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExposureUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseExposureUnion3,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseExposureCustom3$inboundSchema),
  z.lazy(() => CreateManagerResponseExposureGenerated3$inboundSchema),
  z.lazy(() => CreateManagerResponseExposureDisabled3$inboundSchema),
  z.any(),
]);

export function createManagerResponseExposureUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExposureUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExposureUnion3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseKubernetes3$inboundSchema: z.ZodType<
  CreateManagerResponseKubernetes3,
  unknown
> = z.object({
  cluster: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseCluster3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  exposure: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseExposureCustom3$inboundSchema),
      z.lazy(() => CreateManagerResponseExposureGenerated3$inboundSchema),
      z.lazy(() => CreateManagerResponseExposureDisabled3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

export function createManagerResponseKubernetes3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseKubernetes3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseKubernetes3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseKubernetes3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseKubernetesUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseKubernetesUnion3,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseKubernetes3$inboundSchema),
  z.any(),
]);

export function createManagerResponseKubernetesUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseKubernetesUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseKubernetesUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseKubernetesUnion3' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkByoVnetAzure3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseNetworkByoVnetAzure3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkByoVnetAzure3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseNetworkByoVnetAzure3' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkByoVpcGcp3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkByoVpcGcp3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkByoVpcGcp3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkByoVpcGcp3' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkByoVpcAws3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkByoVpcAws3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkByoVpcAws3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkByoVpcAws3' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkCreate3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkCreate3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkCreate3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkCreate3' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseNetworkUseDefault3$inboundSchema: z.ZodType<
  CreateManagerResponseNetworkUseDefault3,
  unknown
> = z.object({
  type: CreateManagerResponseTypeUseDefault3$inboundSchema,
});

export function createManagerResponseNetworkUseDefault3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseNetworkUseDefault3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkUseDefault3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseNetworkUseDefault3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseNetworkUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseNetworkUnion3,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseNetworkByoVpcAws3$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkByoVpcGcp3$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkByoVnetAzure3$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkUseDefault3$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkCreate3$inboundSchema),
  z.any(),
]);

export function createManagerResponseNetworkUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkUnion3' from JSON`,
  );
}

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

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

/** @internal */
export const CreateManagerResponseStackSettings3$inboundSchema: z.ZodType<
  CreateManagerResponseStackSettings3,
  unknown
> = z.object({
  compute: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseCompute3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  deploymentModel: CreateManagerResponseDeploymentModel3$inboundSchema
    .optional(),
  domains: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseDomains3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  externalBindings: z.nullable(
    z.lazy(() => CreateManagerResponseExternalBindings3$inboundSchema),
  ).optional(),
  heartbeats: CreateManagerResponseHeartbeats3$inboundSchema.optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseKubernetes3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  network: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseNetworkByoVpcAws3$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkByoVpcGcp3$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkByoVnetAzure3$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkUseDefault3$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkCreate3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  publicEndpoints: z.nullable(
    z.record(z.string(), z.record(z.string(), z.string())),
  ).optional(),
  telemetry: CreateManagerResponseTelemetry3$inboundSchema.optional(),
  updates: CreateManagerResponseUpdates3$inboundSchema.optional(),
});

export function createManagerResponseStackSettings3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseStackSettings3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseStackSettings3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseStackSettings3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseSetupTerraform$inboundSchema: z.ZodType<
  CreateManagerResponseSetupTerraform,
  unknown
> = z.object({
  method: z.literal("terraform"),
  deploymentPortalUrl: z.string(),
  managerUrl: z.string(),
  providerSource: z.string(),
  moduleSource: z.string(),
  moduleVersion: z.string().optional(),
  moduleInputs: z.record(z.string(), z.string()),
  mainTf: z.string(),
  tfvars: z.string(),
  commands: z.string(),
  stackSettings: z.lazy(() =>
    CreateManagerResponseStackSettings3$inboundSchema
  ),
});

export function createManagerResponseSetupTerraformFromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseSetupTerraform, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseSetupTerraform$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseSetupTerraform' from JSON`,
  );
}

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

export function createManagerResponseFailureDomains4FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseFailureDomains4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomains4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseFailureDomains4' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseFailureDomainsUnion4$inboundSchema: z.ZodType<
  CreateManagerResponseFailureDomainsUnion4,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseFailureDomains4$inboundSchema),
  z.any(),
]);

export function createManagerResponseFailureDomainsUnion4FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseFailureDomainsUnion4,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomainsUnion4$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseFailureDomainsUnion4' from JSON`,
  );
}

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

export function createManagerResponsePoolsAutoscale2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponsePoolsAutoscale2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePoolsAutoscale2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePoolsAutoscale2' from JSON`,
  );
}

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

export function createManagerResponseFailureDomains3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseFailureDomains3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomains3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseFailureDomains3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseFailureDomainsUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseFailureDomainsUnion3,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseFailureDomains3$inboundSchema),
  z.any(),
]);

export function createManagerResponseFailureDomainsUnion3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseFailureDomainsUnion3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomainsUnion3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseFailureDomainsUnion3' from JSON`,
  );
}

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

export function createManagerResponsePoolsFixed2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponsePoolsFixed2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponsePoolsFixed2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePoolsFixed2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponsePoolsUnion2$inboundSchema: z.ZodType<
  CreateManagerResponsePoolsUnion2,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponsePoolsFixed2$inboundSchema),
  z.lazy(() => CreateManagerResponsePoolsAutoscale2$inboundSchema),
]);

export function createManagerResponsePoolsUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponsePoolsUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponsePoolsUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePoolsUnion2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCompute2$inboundSchema: z.ZodType<
  CreateManagerResponseCompute2,
  unknown
> = z.object({
  pools: z.record(
    z.string(),
    z.union([
      z.lazy(() => CreateManagerResponsePoolsFixed2$inboundSchema),
      z.lazy(() => CreateManagerResponsePoolsAutoscale2$inboundSchema),
    ]),
  ).optional(),
});

export function createManagerResponseCompute2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCompute2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCompute2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCompute2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseComputeUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseComputeUnion2,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCompute2$inboundSchema),
  z.any(),
]);

export function createManagerResponseComputeUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseComputeUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseComputeUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseComputeUnion2' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseAws2$inboundSchema: z.ZodType<
  CreateManagerResponseAws2,
  unknown
> = z.object({
  certificateArn: z.string(),
});

export function createManagerResponseAws2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAws2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAws2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAws2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseAwsUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseAwsUnion2,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseAws2$inboundSchema), z.any()]);

export function createManagerResponseAwsUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAwsUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAwsUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAwsUnion2' from JSON`,
  );
}

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

export function createManagerResponseAzure2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAzure2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAzure2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAzure2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseAzureUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseAzureUnion2,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseAzure2$inboundSchema), z.any()]);

export function createManagerResponseAzureUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAzureUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAzureUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAzureUnion2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseGcp2$inboundSchema: z.ZodType<
  CreateManagerResponseGcp2,
  unknown
> = z.object({
  certificateName: z.string(),
});

export function createManagerResponseGcp2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseGcp2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseGcp2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseGcp2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseGcpUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseGcpUnion2,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseGcp2$inboundSchema), z.any()]);

export function createManagerResponseGcpUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseGcpUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseGcpUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseGcpUnion2' from JSON`,
  );
}

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

export function createManagerResponseTlsSecretRef2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseTlsSecretRef2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseTlsSecretRef2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseTlsSecretRef2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsKubernetes2$inboundSchema: z.ZodType<
  CreateManagerResponseDomainsKubernetes2,
  unknown
> = z.object({
  tlsSecretRef: z.lazy(() => CreateManagerResponseTlsSecretRef2$inboundSchema),
});

export function createManagerResponseDomainsKubernetes2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseDomainsKubernetes2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsKubernetes2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseDomainsKubernetes2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsKubernetesUnion2$inboundSchema:
  z.ZodType<CreateManagerResponseDomainsKubernetesUnion2, unknown> = z.union([
    z.lazy(() => CreateManagerResponseDomainsKubernetes2$inboundSchema),
    z.any(),
  ]);

export function createManagerResponseDomainsKubernetesUnion2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseDomainsKubernetesUnion2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsKubernetesUnion2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseDomainsKubernetesUnion2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsCertificate2$inboundSchema: z.ZodType<
  CreateManagerResponseDomainsCertificate2,
  unknown
> = z.object({
  aws: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseAws2$inboundSchema), z.any()]),
  ).optional(),
  azure: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseAzure2$inboundSchema), z.any()]),
  ).optional(),
  gcp: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseGcp2$inboundSchema), z.any()]),
  ).optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseDomainsKubernetes2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

export function createManagerResponseDomainsCertificate2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseDomainsCertificate2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsCertificate2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseDomainsCertificate2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCustomDomains2$inboundSchema: z.ZodType<
  CreateManagerResponseCustomDomains2,
  unknown
> = z.object({
  certificate: z.lazy(() =>
    CreateManagerResponseDomainsCertificate2$inboundSchema
  ),
  domain: z.string(),
});

export function createManagerResponseCustomDomains2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCustomDomains2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCustomDomains2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCustomDomains2' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponsePublicEndpointTargetLoadBalancer2$inboundSchema:
  z.ZodType<CreateManagerResponsePublicEndpointTargetLoadBalancer2, unknown> = z
    .object({
      cnameTarget: z.string(),
      mode: CreateManagerResponseModeLoadBalancer2$inboundSchema,
    });

export function createManagerResponsePublicEndpointTargetLoadBalancer2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponsePublicEndpointTargetLoadBalancer2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePublicEndpointTargetLoadBalancer2$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePublicEndpointTargetLoadBalancer2' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponsePublicEndpointTargetMachineAddresses2$inboundSchema:
  z.ZodType<
    CreateManagerResponsePublicEndpointTargetMachineAddresses2,
    unknown
  > = z.object({
    mode: CreateManagerResponseModeMachineAddresses2$inboundSchema,
  });

export function createManagerResponsePublicEndpointTargetMachineAddresses2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponsePublicEndpointTargetMachineAddresses2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePublicEndpointTargetMachineAddresses2$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePublicEndpointTargetMachineAddresses2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponsePublicEndpointTargetUnion2$inboundSchema:
  z.ZodType<CreateManagerResponsePublicEndpointTargetUnion2, unknown> = z.union(
    [
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetLoadBalancer2$inboundSchema
      ),
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetMachineAddresses2$inboundSchema
      ),
      z.any(),
    ],
  );

export function createManagerResponsePublicEndpointTargetUnion2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponsePublicEndpointTargetUnion2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePublicEndpointTargetUnion2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponsePublicEndpointTargetUnion2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomains2$inboundSchema: z.ZodType<
  CreateManagerResponseDomains2,
  unknown
> = z.object({
  customDomains: z.nullable(
    z.record(
      z.string(),
      z.lazy(() => CreateManagerResponseCustomDomains2$inboundSchema),
    ),
  ).optional(),
  publicEndpointTarget: z.nullable(
    z.union([
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetLoadBalancer2$inboundSchema
      ),
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetMachineAddresses2$inboundSchema
      ),
      z.any(),
    ]),
  ).optional(),
});

export function createManagerResponseDomains2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseDomains2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseDomains2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseDomains2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseDomainsUnion2,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseDomains2$inboundSchema),
  z.any(),
]);

export function createManagerResponseDomainsUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseDomainsUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseDomainsUnion2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExternalBindings2$inboundSchema: z.ZodType<
  CreateManagerResponseExternalBindings2,
  unknown
> = z.object({});

export function createManagerResponseExternalBindings2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExternalBindings2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExternalBindings2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExternalBindings2' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseCloud2$inboundSchema: z.ZodType<
  CreateManagerResponseCloud2,
  unknown
> = z.object({
  accountId: z.nullable(z.string()).optional(),
  clusterId: z.nullable(z.string()).optional(),
  clusterName: z.nullable(z.string()).optional(),
  projectId: z.nullable(z.string()).optional(),
  region: z.nullable(z.string()).optional(),
  resourceGroup: z.nullable(z.string()).optional(),
  subscriptionId: z.nullable(z.string()).optional(),
});

export function createManagerResponseCloud2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCloud2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCloud2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCloud2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCloudUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseCloudUnion2,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseCloud2$inboundSchema), z.any()]);

export function createManagerResponseCloudUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCloudUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCloudUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCloudUnion2' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseCluster2$inboundSchema: z.ZodType<
  CreateManagerResponseCluster2,
  unknown
> = z.object({
  cloud: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseCloud2$inboundSchema), z.any()]),
  ).optional(),
  namespace: z.nullable(z.string()).optional(),
  ownership: CreateManagerResponseOwnership2$inboundSchema,
});

export function createManagerResponseCluster2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCluster2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCluster2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCluster2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseClusterUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseClusterUnion2,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCluster2$inboundSchema),
  z.any(),
]);

export function createManagerResponseClusterUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseClusterUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseClusterUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseClusterUnion2' from JSON`,
  );
}

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

export function createManagerResponseCertificateNone4FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateNone4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateNone4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateNone4' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedTLSSecret4FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedTLSSecret4,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedTLSSecret4$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedTLSSecret4' from JSON`,
  );
}

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

export function createManagerResponseCertificateAwsAcmArn4FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateAwsAcmArn4,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateAwsAcmArn4$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateAwsAcmArn4' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedAcmImport4FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedAcmImport4,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedAcmImport4$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedAcmImport4' from JSON`,
  );
}

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

export function createManagerResponseCertificateTLSSecretRef4FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateTLSSecretRef4,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateTLSSecretRef4$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateTLSSecretRef4' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCertificateUnion4$inboundSchema: z.ZodType<
  CreateManagerResponseCertificateUnion4,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCertificateTLSSecretRef4$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedAcmImport4$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateAwsAcmArn4$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedTLSSecret4$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateNone4$inboundSchema),
]);

export function createManagerResponseCertificateUnion4FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateUnion4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateUnion4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateUnion4' from JSON`,
  );
}

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

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers8$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers8,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum8$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers8FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers8,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers8$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers8' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway8$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway8,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum8$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway8FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway8,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway8$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway8' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb8$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb8,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum8$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb8FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb8, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb8$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb8' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion8$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion8,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb8$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers8$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway8$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion8FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion8, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion8$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion8' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteGateway4$inboundSchema: z.ZodType<
  CreateManagerResponseRouteGateway4,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  gatewayClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  listenerPort: z.int(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb8$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers8$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway8$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

export function createManagerResponseRouteGateway4FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteGateway4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteGateway4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteGateway4' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers7$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers7,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum7$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers7FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers7,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers7$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers7' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway7$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway7,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum7$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway7FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway7,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway7$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway7' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb7$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb7,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum7$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb7FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb7, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb7$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb7' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion7$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion7,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb7$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers7$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway7$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion7FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion7, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion7$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion7' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteIngress4$inboundSchema: z.ZodType<
  CreateManagerResponseRouteIngress4,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  ingressClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb7$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers7$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway7$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

export function createManagerResponseRouteIngress4FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteIngress4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteIngress4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteIngress4' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteUnion4$inboundSchema: z.ZodType<
  CreateManagerResponseRouteUnion4,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseRouteIngress4$inboundSchema),
  z.lazy(() => CreateManagerResponseRouteGateway4$inboundSchema),
]);

export function createManagerResponseRouteUnion4FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteUnion4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseRouteUnion4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteUnion4' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExposureCustom2$inboundSchema: z.ZodType<
  CreateManagerResponseExposureCustom2,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => CreateManagerResponseCertificateTLSSecretRef4$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedAcmImport4$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateAwsAcmArn4$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedTLSSecret4$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateNone4$inboundSchema),
  ]),
  domain: z.string(),
  mode: CreateManagerResponseModeCustom2$inboundSchema,
  route: z.union([
    z.lazy(() => CreateManagerResponseRouteIngress4$inboundSchema),
    z.lazy(() => CreateManagerResponseRouteGateway4$inboundSchema),
  ]),
});

export function createManagerResponseExposureCustom2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExposureCustom2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureCustom2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExposureCustom2' from JSON`,
  );
}

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

export function createManagerResponseCertificateNone3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateNone3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateNone3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateNone3' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedTLSSecret3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedTLSSecret3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedTLSSecret3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedTLSSecret3' from JSON`,
  );
}

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

export function createManagerResponseCertificateAwsAcmArn3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateAwsAcmArn3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateAwsAcmArn3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateAwsAcmArn3' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedAcmImport3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedAcmImport3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedAcmImport3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedAcmImport3' from JSON`,
  );
}

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

export function createManagerResponseCertificateTLSSecretRef3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateTLSSecretRef3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateTLSSecretRef3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateTLSSecretRef3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCertificateUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseCertificateUnion3,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCertificateTLSSecretRef3$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedAcmImport3$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateAwsAcmArn3$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedTLSSecret3$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateNone3$inboundSchema),
]);

export function createManagerResponseCertificateUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateUnion3' from JSON`,
  );
}

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

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers6$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers6,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum6$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers6FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers6,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers6$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers6' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway6$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway6,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum6$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway6FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway6,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway6$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway6' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb6$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb6,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum6$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb6FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb6, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb6$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb6' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion6$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion6,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb6$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers6$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway6$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion6FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion6, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion6$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion6' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteGateway3$inboundSchema: z.ZodType<
  CreateManagerResponseRouteGateway3,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  gatewayClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  listenerPort: z.int(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb6$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers6$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway6$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

export function createManagerResponseRouteGateway3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteGateway3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteGateway3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteGateway3' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers5$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers5,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum5$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers5FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers5,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers5$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers5' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway5$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway5,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum5$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway5FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway5,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway5$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway5' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb5$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb5,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum5$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb5FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb5, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb5$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb5' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion5$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion5,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb5$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers5$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway5$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion5FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion5, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion5$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion5' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteIngress3$inboundSchema: z.ZodType<
  CreateManagerResponseRouteIngress3,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  ingressClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb5$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers5$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway5$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

export function createManagerResponseRouteIngress3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteIngress3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteIngress3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteIngress3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseRouteUnion3,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseRouteIngress3$inboundSchema),
  z.lazy(() => CreateManagerResponseRouteGateway3$inboundSchema),
]);

export function createManagerResponseRouteUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseRouteUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteUnion3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExposureGenerated2$inboundSchema: z.ZodType<
  CreateManagerResponseExposureGenerated2,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => CreateManagerResponseCertificateTLSSecretRef3$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedAcmImport3$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateAwsAcmArn3$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedTLSSecret3$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateNone3$inboundSchema),
  ]),
  mode: CreateManagerResponseModeGenerated2$inboundSchema,
  route: z.union([
    z.lazy(() => CreateManagerResponseRouteIngress3$inboundSchema),
    z.lazy(() => CreateManagerResponseRouteGateway3$inboundSchema),
  ]),
});

export function createManagerResponseExposureGenerated2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseExposureGenerated2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureGenerated2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseExposureGenerated2' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseExposureDisabled2$inboundSchema: z.ZodType<
  CreateManagerResponseExposureDisabled2,
  unknown
> = z.object({
  mode: CreateManagerResponseModeDisabled2$inboundSchema,
});

export function createManagerResponseExposureDisabled2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExposureDisabled2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureDisabled2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExposureDisabled2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExposureUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseExposureUnion2,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseExposureCustom2$inboundSchema),
  z.lazy(() => CreateManagerResponseExposureGenerated2$inboundSchema),
  z.lazy(() => CreateManagerResponseExposureDisabled2$inboundSchema),
  z.any(),
]);

export function createManagerResponseExposureUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExposureUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExposureUnion2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseKubernetes2$inboundSchema: z.ZodType<
  CreateManagerResponseKubernetes2,
  unknown
> = z.object({
  cluster: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseCluster2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  exposure: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseExposureCustom2$inboundSchema),
      z.lazy(() => CreateManagerResponseExposureGenerated2$inboundSchema),
      z.lazy(() => CreateManagerResponseExposureDisabled2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

export function createManagerResponseKubernetes2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseKubernetes2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseKubernetes2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseKubernetes2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseKubernetesUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseKubernetesUnion2,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseKubernetes2$inboundSchema),
  z.any(),
]);

export function createManagerResponseKubernetesUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseKubernetesUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseKubernetesUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseKubernetesUnion2' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkByoVnetAzure2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseNetworkByoVnetAzure2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkByoVnetAzure2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseNetworkByoVnetAzure2' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkByoVpcGcp2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkByoVpcGcp2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkByoVpcGcp2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkByoVpcGcp2' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkByoVpcAws2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkByoVpcAws2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkByoVpcAws2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkByoVpcAws2' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkCreate2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkCreate2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkCreate2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkCreate2' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseNetworkUseDefault2$inboundSchema: z.ZodType<
  CreateManagerResponseNetworkUseDefault2,
  unknown
> = z.object({
  type: CreateManagerResponseTypeUseDefault2$inboundSchema,
});

export function createManagerResponseNetworkUseDefault2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseNetworkUseDefault2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkUseDefault2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseNetworkUseDefault2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseNetworkUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseNetworkUnion2,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseNetworkByoVpcAws2$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkByoVpcGcp2$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkByoVnetAzure2$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkUseDefault2$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkCreate2$inboundSchema),
  z.any(),
]);

export function createManagerResponseNetworkUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkUnion2' from JSON`,
  );
}

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

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

/** @internal */
export const CreateManagerResponseStackSettings2$inboundSchema: z.ZodType<
  CreateManagerResponseStackSettings2,
  unknown
> = z.object({
  compute: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseCompute2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  deploymentModel: CreateManagerResponseDeploymentModel2$inboundSchema
    .optional(),
  domains: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseDomains2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  externalBindings: z.nullable(
    z.lazy(() => CreateManagerResponseExternalBindings2$inboundSchema),
  ).optional(),
  heartbeats: CreateManagerResponseHeartbeats2$inboundSchema.optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseKubernetes2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  network: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseNetworkByoVpcAws2$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkByoVpcGcp2$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkByoVnetAzure2$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkUseDefault2$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkCreate2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  publicEndpoints: z.nullable(
    z.record(z.string(), z.record(z.string(), z.string())),
  ).optional(),
  telemetry: CreateManagerResponseTelemetry2$inboundSchema.optional(),
  updates: CreateManagerResponseUpdates2$inboundSchema.optional(),
});

export function createManagerResponseStackSettings2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseStackSettings2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseStackSettings2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseStackSettings2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseSetupGoogleOauth$inboundSchema: z.ZodType<
  CreateManagerResponseSetupGoogleOauth,
  unknown
> = z.object({
  method: z.literal("google-oauth"),
  deploymentPortalUrl: z.string(),
  managerUrl: z.string(),
  oauthStartUrl: z.string(),
  region: z.string(),
  stackSettings: z.lazy(() =>
    CreateManagerResponseStackSettings2$inboundSchema
  ),
});

export function createManagerResponseSetupGoogleOauthFromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseSetupGoogleOauth, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseSetupGoogleOauth$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseSetupGoogleOauth' from JSON`,
  );
}

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

export function createManagerResponseFailureDomains2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseFailureDomains2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomains2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseFailureDomains2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseFailureDomainsUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseFailureDomainsUnion2,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseFailureDomains2$inboundSchema),
  z.any(),
]);

export function createManagerResponseFailureDomainsUnion2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseFailureDomainsUnion2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomainsUnion2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseFailureDomainsUnion2' from JSON`,
  );
}

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

export function createManagerResponsePoolsAutoscale1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponsePoolsAutoscale1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePoolsAutoscale1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePoolsAutoscale1' from JSON`,
  );
}

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

export function createManagerResponseFailureDomains1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseFailureDomains1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomains1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseFailureDomains1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseFailureDomainsUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseFailureDomainsUnion1,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseFailureDomains1$inboundSchema),
  z.any(),
]);

export function createManagerResponseFailureDomainsUnion1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseFailureDomainsUnion1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseFailureDomainsUnion1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseFailureDomainsUnion1' from JSON`,
  );
}

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

export function createManagerResponsePoolsFixed1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponsePoolsFixed1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponsePoolsFixed1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePoolsFixed1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponsePoolsUnion1$inboundSchema: z.ZodType<
  CreateManagerResponsePoolsUnion1,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponsePoolsFixed1$inboundSchema),
  z.lazy(() => CreateManagerResponsePoolsAutoscale1$inboundSchema),
]);

export function createManagerResponsePoolsUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponsePoolsUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponsePoolsUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePoolsUnion1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCompute1$inboundSchema: z.ZodType<
  CreateManagerResponseCompute1,
  unknown
> = z.object({
  pools: z.record(
    z.string(),
    z.union([
      z.lazy(() => CreateManagerResponsePoolsFixed1$inboundSchema),
      z.lazy(() => CreateManagerResponsePoolsAutoscale1$inboundSchema),
    ]),
  ).optional(),
});

export function createManagerResponseCompute1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCompute1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCompute1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCompute1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseComputeUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseComputeUnion1,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCompute1$inboundSchema),
  z.any(),
]);

export function createManagerResponseComputeUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseComputeUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseComputeUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseComputeUnion1' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseAws1$inboundSchema: z.ZodType<
  CreateManagerResponseAws1,
  unknown
> = z.object({
  certificateArn: z.string(),
});

export function createManagerResponseAws1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAws1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAws1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAws1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseAwsUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseAwsUnion1,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseAws1$inboundSchema), z.any()]);

export function createManagerResponseAwsUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAwsUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAwsUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAwsUnion1' from JSON`,
  );
}

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

export function createManagerResponseAzure1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAzure1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAzure1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAzure1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseAzureUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseAzureUnion1,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseAzure1$inboundSchema), z.any()]);

export function createManagerResponseAzureUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseAzureUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseAzureUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseAzureUnion1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseGcp1$inboundSchema: z.ZodType<
  CreateManagerResponseGcp1,
  unknown
> = z.object({
  certificateName: z.string(),
});

export function createManagerResponseGcp1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseGcp1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseGcp1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseGcp1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseGcpUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseGcpUnion1,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseGcp1$inboundSchema), z.any()]);

export function createManagerResponseGcpUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseGcpUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseGcpUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseGcpUnion1' from JSON`,
  );
}

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

export function createManagerResponseTlsSecretRef1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseTlsSecretRef1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseTlsSecretRef1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseTlsSecretRef1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsKubernetes1$inboundSchema: z.ZodType<
  CreateManagerResponseDomainsKubernetes1,
  unknown
> = z.object({
  tlsSecretRef: z.lazy(() => CreateManagerResponseTlsSecretRef1$inboundSchema),
});

export function createManagerResponseDomainsKubernetes1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseDomainsKubernetes1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsKubernetes1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseDomainsKubernetes1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsKubernetesUnion1$inboundSchema:
  z.ZodType<CreateManagerResponseDomainsKubernetesUnion1, unknown> = z.union([
    z.lazy(() => CreateManagerResponseDomainsKubernetes1$inboundSchema),
    z.any(),
  ]);

export function createManagerResponseDomainsKubernetesUnion1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseDomainsKubernetesUnion1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsKubernetesUnion1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseDomainsKubernetesUnion1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsCertificate1$inboundSchema: z.ZodType<
  CreateManagerResponseDomainsCertificate1,
  unknown
> = z.object({
  aws: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseAws1$inboundSchema), z.any()]),
  ).optional(),
  azure: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseAzure1$inboundSchema), z.any()]),
  ).optional(),
  gcp: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseGcp1$inboundSchema), z.any()]),
  ).optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseDomainsKubernetes1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

export function createManagerResponseDomainsCertificate1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseDomainsCertificate1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsCertificate1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseDomainsCertificate1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCustomDomains1$inboundSchema: z.ZodType<
  CreateManagerResponseCustomDomains1,
  unknown
> = z.object({
  certificate: z.lazy(() =>
    CreateManagerResponseDomainsCertificate1$inboundSchema
  ),
  domain: z.string(),
});

export function createManagerResponseCustomDomains1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCustomDomains1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCustomDomains1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCustomDomains1' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponsePublicEndpointTargetLoadBalancer1$inboundSchema:
  z.ZodType<CreateManagerResponsePublicEndpointTargetLoadBalancer1, unknown> = z
    .object({
      cnameTarget: z.string(),
      mode: CreateManagerResponseModeLoadBalancer1$inboundSchema,
    });

export function createManagerResponsePublicEndpointTargetLoadBalancer1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponsePublicEndpointTargetLoadBalancer1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePublicEndpointTargetLoadBalancer1$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePublicEndpointTargetLoadBalancer1' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponsePublicEndpointTargetMachineAddresses1$inboundSchema:
  z.ZodType<
    CreateManagerResponsePublicEndpointTargetMachineAddresses1,
    unknown
  > = z.object({
    mode: CreateManagerResponseModeMachineAddresses1$inboundSchema,
  });

export function createManagerResponsePublicEndpointTargetMachineAddresses1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponsePublicEndpointTargetMachineAddresses1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePublicEndpointTargetMachineAddresses1$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponsePublicEndpointTargetMachineAddresses1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponsePublicEndpointTargetUnion1$inboundSchema:
  z.ZodType<CreateManagerResponsePublicEndpointTargetUnion1, unknown> = z.union(
    [
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetLoadBalancer1$inboundSchema
      ),
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetMachineAddresses1$inboundSchema
      ),
      z.any(),
    ],
  );

export function createManagerResponsePublicEndpointTargetUnion1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponsePublicEndpointTargetUnion1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponsePublicEndpointTargetUnion1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponsePublicEndpointTargetUnion1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomains1$inboundSchema: z.ZodType<
  CreateManagerResponseDomains1,
  unknown
> = z.object({
  customDomains: z.nullable(
    z.record(
      z.string(),
      z.lazy(() => CreateManagerResponseCustomDomains1$inboundSchema),
    ),
  ).optional(),
  publicEndpointTarget: z.nullable(
    z.union([
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetLoadBalancer1$inboundSchema
      ),
      z.lazy(() =>
        CreateManagerResponsePublicEndpointTargetMachineAddresses1$inboundSchema
      ),
      z.any(),
    ]),
  ).optional(),
});

export function createManagerResponseDomains1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseDomains1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseDomains1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseDomains1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseDomainsUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseDomainsUnion1,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseDomains1$inboundSchema),
  z.any(),
]);

export function createManagerResponseDomainsUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseDomainsUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseDomainsUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseDomainsUnion1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExternalBindings1$inboundSchema: z.ZodType<
  CreateManagerResponseExternalBindings1,
  unknown
> = z.object({});

export function createManagerResponseExternalBindings1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExternalBindings1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExternalBindings1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExternalBindings1' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseCloud1$inboundSchema: z.ZodType<
  CreateManagerResponseCloud1,
  unknown
> = z.object({
  accountId: z.nullable(z.string()).optional(),
  clusterId: z.nullable(z.string()).optional(),
  clusterName: z.nullable(z.string()).optional(),
  projectId: z.nullable(z.string()).optional(),
  region: z.nullable(z.string()).optional(),
  resourceGroup: z.nullable(z.string()).optional(),
  subscriptionId: z.nullable(z.string()).optional(),
});

export function createManagerResponseCloud1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCloud1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCloud1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCloud1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCloudUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseCloudUnion1,
  unknown
> = z.union([z.lazy(() => CreateManagerResponseCloud1$inboundSchema), z.any()]);

export function createManagerResponseCloudUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCloudUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCloudUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCloudUnion1' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseCluster1$inboundSchema: z.ZodType<
  CreateManagerResponseCluster1,
  unknown
> = z.object({
  cloud: z.nullable(
    z.union([z.lazy(() => CreateManagerResponseCloud1$inboundSchema), z.any()]),
  ).optional(),
  namespace: z.nullable(z.string()).optional(),
  ownership: CreateManagerResponseOwnership1$inboundSchema,
});

export function createManagerResponseCluster1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCluster1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseCluster1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCluster1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseClusterUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseClusterUnion1,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCluster1$inboundSchema),
  z.any(),
]);

export function createManagerResponseClusterUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseClusterUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseClusterUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseClusterUnion1' from JSON`,
  );
}

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

export function createManagerResponseCertificateNone2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateNone2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateNone2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateNone2' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedTLSSecret2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedTLSSecret2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedTLSSecret2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedTLSSecret2' from JSON`,
  );
}

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

export function createManagerResponseCertificateAwsAcmArn2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateAwsAcmArn2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateAwsAcmArn2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateAwsAcmArn2' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedAcmImport2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedAcmImport2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedAcmImport2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedAcmImport2' from JSON`,
  );
}

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

export function createManagerResponseCertificateTLSSecretRef2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateTLSSecretRef2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateTLSSecretRef2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateTLSSecretRef2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCertificateUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseCertificateUnion2,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCertificateTLSSecretRef2$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedAcmImport2$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateAwsAcmArn2$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedTLSSecret2$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateNone2$inboundSchema),
]);

export function createManagerResponseCertificateUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateUnion2' from JSON`,
  );
}

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

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers4$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers4,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum4$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers4FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers4,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers4$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers4' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway4$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway4,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum4$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway4FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway4,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway4$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway4' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb4$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb4,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum4$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb4FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb4' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion4$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion4,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb4$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers4$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway4$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion4FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion4' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteGateway2$inboundSchema: z.ZodType<
  CreateManagerResponseRouteGateway2,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  gatewayClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  listenerPort: z.int(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb4$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers4$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway4$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

export function createManagerResponseRouteGateway2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteGateway2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteGateway2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteGateway2' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers3$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers3,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum3$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers3$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers3' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway3$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway3,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum3$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway3FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway3' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb3$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb3,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum3$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion3$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion3,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb3$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers3$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway3$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion3FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion3' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteIngress2$inboundSchema: z.ZodType<
  CreateManagerResponseRouteIngress2,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  ingressClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb3$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers3$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

export function createManagerResponseRouteIngress2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteIngress2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteIngress2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteIngress2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseRouteUnion2,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseRouteIngress2$inboundSchema),
  z.lazy(() => CreateManagerResponseRouteGateway2$inboundSchema),
]);

export function createManagerResponseRouteUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseRouteUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteUnion2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExposureCustom1$inboundSchema: z.ZodType<
  CreateManagerResponseExposureCustom1,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => CreateManagerResponseCertificateTLSSecretRef2$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedAcmImport2$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateAwsAcmArn2$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedTLSSecret2$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateNone2$inboundSchema),
  ]),
  domain: z.string(),
  mode: CreateManagerResponseModeCustom1$inboundSchema,
  route: z.union([
    z.lazy(() => CreateManagerResponseRouteIngress2$inboundSchema),
    z.lazy(() => CreateManagerResponseRouteGateway2$inboundSchema),
  ]),
});

export function createManagerResponseExposureCustom1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExposureCustom1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureCustom1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExposureCustom1' from JSON`,
  );
}

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

export function createManagerResponseCertificateNone1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateNone1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateNone1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateNone1' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedTLSSecret1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedTLSSecret1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedTLSSecret1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedTLSSecret1' from JSON`,
  );
}

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

export function createManagerResponseCertificateAwsAcmArn1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateAwsAcmArn1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateAwsAcmArn1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateAwsAcmArn1' from JSON`,
  );
}

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

export function createManagerResponseCertificateManagedAcmImport1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateManagedAcmImport1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateManagedAcmImport1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateManagedAcmImport1' from JSON`,
  );
}

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

export function createManagerResponseCertificateTLSSecretRef1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseCertificateTLSSecretRef1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateTLSSecretRef1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseCertificateTLSSecretRef1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseCertificateUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseCertificateUnion1,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseCertificateTLSSecretRef1$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedAcmImport1$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateAwsAcmArn1$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateManagedTLSSecret1$inboundSchema),
  z.lazy(() => CreateManagerResponseCertificateNone1$inboundSchema),
]);

export function createManagerResponseCertificateUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseCertificateUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseCertificateUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseCertificateUnion1' from JSON`,
  );
}

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

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers2$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers2,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum2$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers2$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers2' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway2$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway2,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum2$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway2FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway2' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb2$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb2,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum2$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion2$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion2,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb2$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers2$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway2$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion2FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion2' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteGateway1$inboundSchema: z.ZodType<
  CreateManagerResponseRouteGateway1,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  gatewayClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  listenerPort: z.int(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb2$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers2$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

export function createManagerResponseRouteGateway1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteGateway1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteGateway1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteGateway1' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAzureApplicationGatewayForContainers1$inboundSchema:
  z.ZodType<
    CreateManagerResponseProviderAzureApplicationGatewayForContainers1,
    unknown
  > = z.object({
    albName: z.nullable(z.string()).optional(),
    albNamespace: z.nullable(z.string()).optional(),
    frontend: z.string(),
    provider:
      CreateManagerResponseProviderAzureApplicationGatewayForContainersEnum1$inboundSchema,
  });

export function createManagerResponseProviderAzureApplicationGatewayForContainers1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderAzureApplicationGatewayForContainers1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAzureApplicationGatewayForContainers1$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAzureApplicationGatewayForContainers1' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderGkeGateway1$inboundSchema: z.ZodType<
  CreateManagerResponseProviderGkeGateway1,
  unknown
> = z.object({
  provider: CreateManagerResponseProviderGkeGatewayEnum1$inboundSchema,
  staticAddressName: z.nullable(z.string()).optional(),
});

export function createManagerResponseProviderGkeGateway1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseProviderGkeGateway1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderGkeGateway1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseProviderGkeGateway1' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseProviderAwsAlb1$inboundSchema: z.ZodType<
  CreateManagerResponseProviderAwsAlb1,
  unknown
> = z.object({
  ipAddressType: z.nullable(z.string()).optional(),
  provider: CreateManagerResponseProviderAwsAlbEnum1$inboundSchema,
  scheme: z.string(),
  subnetIds: z.array(z.string()).optional(),
  targetType: z.string(),
});

export function createManagerResponseProviderAwsAlb1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderAwsAlb1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderAwsAlb1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderAwsAlb1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseProviderUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseProviderUnion1,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseProviderAwsAlb1$inboundSchema),
  z.lazy(() =>
    CreateManagerResponseProviderAzureApplicationGatewayForContainers1$inboundSchema
  ),
  z.lazy(() => CreateManagerResponseProviderGkeGateway1$inboundSchema),
  z.any(),
]);

export function createManagerResponseProviderUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseProviderUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseProviderUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseProviderUnion1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteIngress1$inboundSchema: z.ZodType<
  CreateManagerResponseRouteIngress1,
  unknown
> = z.object({
  annotations: z.record(z.string(), z.string()).optional(),
  controller: z.nullable(z.string()).optional(),
  ingressClassName: z.string(),
  labels: z.record(z.string(), z.string()).optional(),
  provider: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseProviderAwsAlb1$inboundSchema),
      z.lazy(() =>
        CreateManagerResponseProviderAzureApplicationGatewayForContainers1$inboundSchema
      ),
      z.lazy(() => CreateManagerResponseProviderGkeGateway1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

export function createManagerResponseRouteIngress1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteIngress1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseRouteIngress1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteIngress1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseRouteUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseRouteUnion1,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseRouteIngress1$inboundSchema),
  z.lazy(() => CreateManagerResponseRouteGateway1$inboundSchema),
]);

export function createManagerResponseRouteUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseRouteUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseRouteUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseRouteUnion1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExposureGenerated1$inboundSchema: z.ZodType<
  CreateManagerResponseExposureGenerated1,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => CreateManagerResponseCertificateTLSSecretRef1$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedAcmImport1$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateAwsAcmArn1$inboundSchema),
    z.lazy(() =>
      CreateManagerResponseCertificateManagedTLSSecret1$inboundSchema
    ),
    z.lazy(() => CreateManagerResponseCertificateNone1$inboundSchema),
  ]),
  mode: CreateManagerResponseModeGenerated1$inboundSchema,
  route: z.union([
    z.lazy(() => CreateManagerResponseRouteIngress1$inboundSchema),
    z.lazy(() => CreateManagerResponseRouteGateway1$inboundSchema),
  ]),
});

export function createManagerResponseExposureGenerated1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseExposureGenerated1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureGenerated1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseExposureGenerated1' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseExposureDisabled1$inboundSchema: z.ZodType<
  CreateManagerResponseExposureDisabled1,
  unknown
> = z.object({
  mode: CreateManagerResponseModeDisabled1$inboundSchema,
});

export function createManagerResponseExposureDisabled1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExposureDisabled1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureDisabled1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExposureDisabled1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseExposureUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseExposureUnion1,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseExposureCustom1$inboundSchema),
  z.lazy(() => CreateManagerResponseExposureGenerated1$inboundSchema),
  z.lazy(() => CreateManagerResponseExposureDisabled1$inboundSchema),
  z.any(),
]);

export function createManagerResponseExposureUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseExposureUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseExposureUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseExposureUnion1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseKubernetes1$inboundSchema: z.ZodType<
  CreateManagerResponseKubernetes1,
  unknown
> = z.object({
  cluster: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseCluster1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  exposure: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseExposureCustom1$inboundSchema),
      z.lazy(() => CreateManagerResponseExposureGenerated1$inboundSchema),
      z.lazy(() => CreateManagerResponseExposureDisabled1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

export function createManagerResponseKubernetes1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseKubernetes1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseKubernetes1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseKubernetes1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseKubernetesUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseKubernetesUnion1,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseKubernetes1$inboundSchema),
  z.any(),
]);

export function createManagerResponseKubernetesUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseKubernetesUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseKubernetesUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseKubernetesUnion1' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkByoVnetAzure1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseNetworkByoVnetAzure1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkByoVnetAzure1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseNetworkByoVnetAzure1' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkByoVpcGcp1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkByoVpcGcp1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkByoVpcGcp1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkByoVpcGcp1' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkByoVpcAws1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkByoVpcAws1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkByoVpcAws1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkByoVpcAws1' from JSON`,
  );
}

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

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

export function createManagerResponseNetworkCreate1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkCreate1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkCreate1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkCreate1' from JSON`,
  );
}

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

/** @internal */
export const CreateManagerResponseNetworkUseDefault1$inboundSchema: z.ZodType<
  CreateManagerResponseNetworkUseDefault1,
  unknown
> = z.object({
  type: CreateManagerResponseTypeUseDefault1$inboundSchema,
});

export function createManagerResponseNetworkUseDefault1FromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseNetworkUseDefault1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkUseDefault1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseNetworkUseDefault1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseNetworkUnion1$inboundSchema: z.ZodType<
  CreateManagerResponseNetworkUnion1,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseNetworkByoVpcAws1$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkByoVpcGcp1$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkByoVnetAzure1$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkUseDefault1$inboundSchema),
  z.lazy(() => CreateManagerResponseNetworkCreate1$inboundSchema),
  z.any(),
]);

export function createManagerResponseNetworkUnion1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseNetworkUnion1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseNetworkUnion1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseNetworkUnion1' from JSON`,
  );
}

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

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

/** @internal */
export const CreateManagerResponseStackSettings1$inboundSchema: z.ZodType<
  CreateManagerResponseStackSettings1,
  unknown
> = z.object({
  compute: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseCompute1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  deploymentModel: CreateManagerResponseDeploymentModel1$inboundSchema
    .optional(),
  domains: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseDomains1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  externalBindings: z.nullable(
    z.lazy(() => CreateManagerResponseExternalBindings1$inboundSchema),
  ).optional(),
  heartbeats: CreateManagerResponseHeartbeats1$inboundSchema.optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseKubernetes1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  network: z.nullable(
    z.union([
      z.lazy(() => CreateManagerResponseNetworkByoVpcAws1$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkByoVpcGcp1$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkByoVnetAzure1$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkUseDefault1$inboundSchema),
      z.lazy(() => CreateManagerResponseNetworkCreate1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  publicEndpoints: z.nullable(
    z.record(z.string(), z.record(z.string(), z.string())),
  ).optional(),
  telemetry: CreateManagerResponseTelemetry1$inboundSchema.optional(),
  updates: CreateManagerResponseUpdates1$inboundSchema.optional(),
});

export function createManagerResponseStackSettings1FromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseStackSettings1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseStackSettings1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseStackSettings1' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseSetupCloudformation$inboundSchema: z.ZodType<
  CreateManagerResponseSetupCloudformation,
  unknown
> = z.object({
  method: z.literal("cloudformation"),
  deploymentPortalUrl: z.string(),
  launchUrl: z.string(),
  templateUrl: z.string(),
  stackName: z.string(),
  region: z.string(),
  stackSettings: z.lazy(() =>
    CreateManagerResponseStackSettings1$inboundSchema
  ),
});

export function createManagerResponseSetupCloudformationFromJSON(
  jsonString: string,
): SafeParseResult<
  CreateManagerResponseSetupCloudformation,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      CreateManagerResponseSetupCloudformation$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'CreateManagerResponseSetupCloudformation' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponseSetupUnion$inboundSchema: z.ZodType<
  CreateManagerResponseSetupUnion,
  unknown
> = z.union([
  z.lazy(() => CreateManagerResponseSetupCloudformation$inboundSchema),
  z.lazy(() => CreateManagerResponseSetupGoogleOauth$inboundSchema),
  z.lazy(() => CreateManagerResponseSetupTerraform$inboundSchema),
]);

export function createManagerResponseSetupUnionFromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponseSetupUnion, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponseSetupUnion$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponseSetupUnion' from JSON`,
  );
}

/** @internal */
export const CreateManagerResponse$inboundSchema: z.ZodType<
  CreateManagerResponse,
  unknown
> = z.object({
  managerId: z.string(),
  setupStatus: CreateManagerResponseSetupStatus$inboundSchema,
  setupToken: z.string(),
  setupTokenId: z.string(),
  deploymentLink: z.string(),
  setupConfig: z.lazy(() => CreateManagerResponseSetupConfig$inboundSchema),
  setup: z.union([
    z.lazy(() => CreateManagerResponseSetupCloudformation$inboundSchema),
    z.lazy(() => CreateManagerResponseSetupGoogleOauth$inboundSchema),
    z.lazy(() => CreateManagerResponseSetupTerraform$inboundSchema),
  ]),
});

export function createManagerResponseFromJSON(
  jsonString: string,
): SafeParseResult<CreateManagerResponse, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateManagerResponse$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateManagerResponse' from JSON`,
  );
}