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

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";
import {
  ManagerRetryDeploymentResponse,
  ManagerRetryDeploymentResponse$inboundSchema,
} from "./managerretrydeploymentresponse.js";

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

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

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

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

export type ManagerRetryResponseSourceUnion =
  | ManagerRetryResponseSourceProjectRelease
  | ManagerRetryResponseSourceBuiltIn;

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

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

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

export type ManagerRetryResponseModelRequirement = {
  publicModelId: string;
  clientApis: Array<ManagerRetryResponseClientApi>;
  required: boolean;
};

export type ManagerRetryResponseConfiguration = {
  allowedProviders?: Array<ManagerRetryResponseAllowedProvider> | undefined;
  providerAllowlist?: Array<ManagerRetryResponseProviderAllowlist> | undefined;
  modelRequirements?: Array<ManagerRetryResponseModelRequirement> | undefined;
};

export type ManagerRetryResponseItem = {
  item: ManagerRetryResponseItemEnum;
  source:
    | ManagerRetryResponseSourceProjectRelease
    | ManagerRetryResponseSourceBuiltIn;
  required: boolean;
  configuration?: ManagerRetryResponseConfiguration | undefined;
};

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

export type ManagerRetryResponseEnvironmentVariable = {
  name: string;
  type: ManagerRetryResponseEnvironmentVariableType;
  targetResources: Array<string> | null;
};

export type ManagerRetryResponseSetupConfig = {
  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<ManagerRetryResponseItem> | undefined;
  /**
   * Operator-pinned deployment subdomain for this setup token.
   */
  publicSubdomain?: string | undefined;
  environmentVariables: Array<ManagerRetryResponseEnvironmentVariable>;
};

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

export type ManagerRetryResponsePoolsAutoscale3 = {
  failureDomains?: ManagerRetryResponseFailureDomains6 | 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 ManagerRetryResponseFailureDomains5 = {
  /**
   * 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 ManagerRetryResponseFailureDomainsUnion5 =
  | ManagerRetryResponseFailureDomains5
  | any;

export type ManagerRetryResponsePoolsFixed3 = {
  failureDomains?: ManagerRetryResponseFailureDomains5 | 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 ManagerRetryResponsePoolsUnion3 =
  | ManagerRetryResponsePoolsFixed3
  | ManagerRetryResponsePoolsAutoscale3;

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

export type ManagerRetryResponseComputeUnion3 =
  | ManagerRetryResponseCompute3
  | any;

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

export type ManagerRetryResponseAws3 = {
  certificateArn: string;
};

export type ManagerRetryResponseAwsUnion3 = ManagerRetryResponseAws3 | any;

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

export type ManagerRetryResponseAzureUnion3 = ManagerRetryResponseAzure3 | any;

export type ManagerRetryResponseGcp3 = {
  certificateName: string;
};

export type ManagerRetryResponseGcpUnion3 = ManagerRetryResponseGcp3 | any;

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

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

export type ManagerRetryResponseDomainsKubernetesUnion3 =
  | ManagerRetryResponseDomainsKubernetes3
  | any;

/**
 * Platform-specific certificate references for custom domains.
 */
export type ManagerRetryResponseDomainsCertificate3 = {
  aws?: ManagerRetryResponseAws3 | any | null | undefined;
  azure?: ManagerRetryResponseAzure3 | any | null | undefined;
  gcp?: ManagerRetryResponseGcp3 | any | null | undefined;
  kubernetes?: ManagerRetryResponseDomainsKubernetes3 | any | null | undefined;
};

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

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

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

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

export type ManagerRetryResponsePublicEndpointTargetMachineAddresses3 = {
  mode: ManagerRetryResponseModeMachineAddresses3;
};

export type ManagerRetryResponsePublicEndpointTargetUnion3 =
  | ManagerRetryResponsePublicEndpointTargetLoadBalancer3
  | ManagerRetryResponsePublicEndpointTargetMachineAddresses3
  | 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 ManagerRetryResponseDomains3 = {
  /**
   * Custom domain configuration per resource ID.
   */
  customDomains?:
    | { [k: string]: ManagerRetryResponseCustomDomains3 }
    | null
    | undefined;
  publicEndpointTarget?:
    | ManagerRetryResponsePublicEndpointTargetLoadBalancer3
    | ManagerRetryResponsePublicEndpointTargetMachineAddresses3
    | any
    | null
    | undefined;
};

export type ManagerRetryResponseDomainsUnion3 =
  | ManagerRetryResponseDomains3
  | 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 ManagerRetryResponseExternalBindings3 = {};

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

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

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

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

export type ManagerRetryResponseClusterUnion3 =
  | ManagerRetryResponseCluster3
  | any;

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

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

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

export type ManagerRetryResponseCertificateManagedAcmImport6 = {
  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 ManagerRetryResponseCertificateTLSSecretRef6 = {
  /**
   * 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 ManagerRetryResponseCertificateUnion6 =
  | ManagerRetryResponseCertificateTLSSecretRef6
  | ManagerRetryResponseCertificateManagedAcmImport6
  | ManagerRetryResponseCertificateAwsAcmArn6
  | ManagerRetryResponseCertificateManagedTLSSecret6
  | ManagerRetryResponseCertificateNone6;

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

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb12 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum12;
  /**
   * 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 ManagerRetryResponseProviderUnion12 =
  | ManagerRetryResponseProviderAwsAlb12
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers12
  | ManagerRetryResponseProviderGkeGateway12
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type ManagerRetryResponseRouteGateway6 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb12
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers12
    | ManagerRetryResponseProviderGkeGateway12
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb11 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum11;
  /**
   * 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 ManagerRetryResponseProviderUnion11 =
  | ManagerRetryResponseProviderAwsAlb11
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers11
  | ManagerRetryResponseProviderGkeGateway11
  | any;

/**
 * Shared Ingress route profile values.
 */
export type ManagerRetryResponseRouteIngress6 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb11
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers11
    | ManagerRetryResponseProviderGkeGateway11
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type ManagerRetryResponseRouteUnion6 =
  | ManagerRetryResponseRouteIngress6
  | ManagerRetryResponseRouteGateway6;

export type ManagerRetryResponseExposureCustom3 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | ManagerRetryResponseCertificateTLSSecretRef6
    | ManagerRetryResponseCertificateManagedAcmImport6
    | ManagerRetryResponseCertificateAwsAcmArn6
    | ManagerRetryResponseCertificateManagedTLSSecret6
    | ManagerRetryResponseCertificateNone6;
  /**
   * Hostname routed by the Kubernetes public endpoint.
   */
  domain: string;
  mode: ManagerRetryResponseModeCustom3;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: ManagerRetryResponseRouteIngress6 | ManagerRetryResponseRouteGateway6;
};

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

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

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

export type ManagerRetryResponseCertificateManagedAcmImport5 = {
  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 ManagerRetryResponseCertificateTLSSecretRef5 = {
  /**
   * 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 ManagerRetryResponseCertificateUnion5 =
  | ManagerRetryResponseCertificateTLSSecretRef5
  | ManagerRetryResponseCertificateManagedAcmImport5
  | ManagerRetryResponseCertificateAwsAcmArn5
  | ManagerRetryResponseCertificateManagedTLSSecret5
  | ManagerRetryResponseCertificateNone5;

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

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb10 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum10;
  /**
   * 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 ManagerRetryResponseProviderUnion10 =
  | ManagerRetryResponseProviderAwsAlb10
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers10
  | ManagerRetryResponseProviderGkeGateway10
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type ManagerRetryResponseRouteGateway5 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb10
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers10
    | ManagerRetryResponseProviderGkeGateway10
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb9 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum9;
  /**
   * 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 ManagerRetryResponseProviderUnion9 =
  | ManagerRetryResponseProviderAwsAlb9
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers9
  | ManagerRetryResponseProviderGkeGateway9
  | any;

/**
 * Shared Ingress route profile values.
 */
export type ManagerRetryResponseRouteIngress5 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb9
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers9
    | ManagerRetryResponseProviderGkeGateway9
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type ManagerRetryResponseRouteUnion5 =
  | ManagerRetryResponseRouteIngress5
  | ManagerRetryResponseRouteGateway5;

export type ManagerRetryResponseExposureGenerated3 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | ManagerRetryResponseCertificateTLSSecretRef5
    | ManagerRetryResponseCertificateManagedAcmImport5
    | ManagerRetryResponseCertificateAwsAcmArn5
    | ManagerRetryResponseCertificateManagedTLSSecret5
    | ManagerRetryResponseCertificateNone5;
  mode: ManagerRetryResponseModeGenerated3;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: ManagerRetryResponseRouteIngress5 | ManagerRetryResponseRouteGateway5;
};

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

export type ManagerRetryResponseExposureDisabled3 = {
  mode: ManagerRetryResponseModeDisabled3;
};

export type ManagerRetryResponseExposureUnion3 =
  | ManagerRetryResponseExposureCustom3
  | ManagerRetryResponseExposureGenerated3
  | ManagerRetryResponseExposureDisabled3
  | 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 ManagerRetryResponseKubernetes3 = {
  cluster?: ManagerRetryResponseCluster3 | any | null | undefined;
  exposure?:
    | ManagerRetryResponseExposureCustom3
    | ManagerRetryResponseExposureGenerated3
    | ManagerRetryResponseExposureDisabled3
    | any
    | null
    | undefined;
};

export type ManagerRetryResponseKubernetesUnion3 =
  | ManagerRetryResponseKubernetes3
  | any;

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

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

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

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

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

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

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

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

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

export type ManagerRetryResponseNetworkUseDefault3 = {
  type: ManagerRetryResponseTypeUseDefault3;
};

export type ManagerRetryResponseNetworkUnion3 =
  | ManagerRetryResponseNetworkByoVpcAws3
  | ManagerRetryResponseNetworkByoVpcGcp3
  | ManagerRetryResponseNetworkByoVnetAzure3
  | ManagerRetryResponseNetworkUseDefault3
  | ManagerRetryResponseNetworkCreate3
  | any;

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

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

/**
 * 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 ManagerRetryResponseStackSettings3 = {
  compute?: ManagerRetryResponseCompute3 | any | null | undefined;
  /**
   * Deployment model: how updates are delivered to the remote environment.
   */
  deploymentModel?: ManagerRetryResponseDeploymentModel3 | undefined;
  domains?: ManagerRetryResponseDomains3 | 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?: ManagerRetryResponseExternalBindings3 | null | undefined;
  /**
   * How heartbeat health checks are handled.
   */
  heartbeats?: ManagerRetryResponseHeartbeats3 | undefined;
  kubernetes?: ManagerRetryResponseKubernetes3 | any | null | undefined;
  network?:
    | ManagerRetryResponseNetworkByoVpcAws3
    | ManagerRetryResponseNetworkByoVpcGcp3
    | ManagerRetryResponseNetworkByoVnetAzure3
    | ManagerRetryResponseNetworkUseDefault3
    | ManagerRetryResponseNetworkCreate3
    | 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?: ManagerRetryResponseTelemetry3 | undefined;
  /**
   * How updates are delivered to the deployment.
   */
  updates?: ManagerRetryResponseUpdates3 | undefined;
};

export type ManagerRetryResponseSetupTerraform = {
  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: ManagerRetryResponseStackSettings3;
};

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

export type ManagerRetryResponsePoolsAutoscale2 = {
  failureDomains?: ManagerRetryResponseFailureDomains4 | 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 ManagerRetryResponseFailureDomains3 = {
  /**
   * 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 ManagerRetryResponseFailureDomainsUnion3 =
  | ManagerRetryResponseFailureDomains3
  | any;

export type ManagerRetryResponsePoolsFixed2 = {
  failureDomains?: ManagerRetryResponseFailureDomains3 | 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 ManagerRetryResponsePoolsUnion2 =
  | ManagerRetryResponsePoolsFixed2
  | ManagerRetryResponsePoolsAutoscale2;

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

export type ManagerRetryResponseComputeUnion2 =
  | ManagerRetryResponseCompute2
  | any;

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

export type ManagerRetryResponseAws2 = {
  certificateArn: string;
};

export type ManagerRetryResponseAwsUnion2 = ManagerRetryResponseAws2 | any;

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

export type ManagerRetryResponseAzureUnion2 = ManagerRetryResponseAzure2 | any;

export type ManagerRetryResponseGcp2 = {
  certificateName: string;
};

export type ManagerRetryResponseGcpUnion2 = ManagerRetryResponseGcp2 | any;

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

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

export type ManagerRetryResponseDomainsKubernetesUnion2 =
  | ManagerRetryResponseDomainsKubernetes2
  | any;

/**
 * Platform-specific certificate references for custom domains.
 */
export type ManagerRetryResponseDomainsCertificate2 = {
  aws?: ManagerRetryResponseAws2 | any | null | undefined;
  azure?: ManagerRetryResponseAzure2 | any | null | undefined;
  gcp?: ManagerRetryResponseGcp2 | any | null | undefined;
  kubernetes?: ManagerRetryResponseDomainsKubernetes2 | any | null | undefined;
};

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

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

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

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

export type ManagerRetryResponsePublicEndpointTargetMachineAddresses2 = {
  mode: ManagerRetryResponseModeMachineAddresses2;
};

export type ManagerRetryResponsePublicEndpointTargetUnion2 =
  | ManagerRetryResponsePublicEndpointTargetLoadBalancer2
  | ManagerRetryResponsePublicEndpointTargetMachineAddresses2
  | 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 ManagerRetryResponseDomains2 = {
  /**
   * Custom domain configuration per resource ID.
   */
  customDomains?:
    | { [k: string]: ManagerRetryResponseCustomDomains2 }
    | null
    | undefined;
  publicEndpointTarget?:
    | ManagerRetryResponsePublicEndpointTargetLoadBalancer2
    | ManagerRetryResponsePublicEndpointTargetMachineAddresses2
    | any
    | null
    | undefined;
};

export type ManagerRetryResponseDomainsUnion2 =
  | ManagerRetryResponseDomains2
  | 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 ManagerRetryResponseExternalBindings2 = {};

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

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

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

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

export type ManagerRetryResponseClusterUnion2 =
  | ManagerRetryResponseCluster2
  | any;

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

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

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

export type ManagerRetryResponseCertificateManagedAcmImport4 = {
  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 ManagerRetryResponseCertificateTLSSecretRef4 = {
  /**
   * 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 ManagerRetryResponseCertificateUnion4 =
  | ManagerRetryResponseCertificateTLSSecretRef4
  | ManagerRetryResponseCertificateManagedAcmImport4
  | ManagerRetryResponseCertificateAwsAcmArn4
  | ManagerRetryResponseCertificateManagedTLSSecret4
  | ManagerRetryResponseCertificateNone4;

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

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb8 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum8;
  /**
   * 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 ManagerRetryResponseProviderUnion8 =
  | ManagerRetryResponseProviderAwsAlb8
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers8
  | ManagerRetryResponseProviderGkeGateway8
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type ManagerRetryResponseRouteGateway4 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb8
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers8
    | ManagerRetryResponseProviderGkeGateway8
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb7 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum7;
  /**
   * 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 ManagerRetryResponseProviderUnion7 =
  | ManagerRetryResponseProviderAwsAlb7
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers7
  | ManagerRetryResponseProviderGkeGateway7
  | any;

/**
 * Shared Ingress route profile values.
 */
export type ManagerRetryResponseRouteIngress4 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb7
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers7
    | ManagerRetryResponseProviderGkeGateway7
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type ManagerRetryResponseRouteUnion4 =
  | ManagerRetryResponseRouteIngress4
  | ManagerRetryResponseRouteGateway4;

export type ManagerRetryResponseExposureCustom2 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | ManagerRetryResponseCertificateTLSSecretRef4
    | ManagerRetryResponseCertificateManagedAcmImport4
    | ManagerRetryResponseCertificateAwsAcmArn4
    | ManagerRetryResponseCertificateManagedTLSSecret4
    | ManagerRetryResponseCertificateNone4;
  /**
   * Hostname routed by the Kubernetes public endpoint.
   */
  domain: string;
  mode: ManagerRetryResponseModeCustom2;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: ManagerRetryResponseRouteIngress4 | ManagerRetryResponseRouteGateway4;
};

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

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

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

export type ManagerRetryResponseCertificateManagedAcmImport3 = {
  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 ManagerRetryResponseCertificateTLSSecretRef3 = {
  /**
   * 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 ManagerRetryResponseCertificateUnion3 =
  | ManagerRetryResponseCertificateTLSSecretRef3
  | ManagerRetryResponseCertificateManagedAcmImport3
  | ManagerRetryResponseCertificateAwsAcmArn3
  | ManagerRetryResponseCertificateManagedTLSSecret3
  | ManagerRetryResponseCertificateNone3;

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

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb6 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum6;
  /**
   * 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 ManagerRetryResponseProviderUnion6 =
  | ManagerRetryResponseProviderAwsAlb6
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers6
  | ManagerRetryResponseProviderGkeGateway6
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type ManagerRetryResponseRouteGateway3 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb6
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers6
    | ManagerRetryResponseProviderGkeGateway6
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb5 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum5;
  /**
   * 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 ManagerRetryResponseProviderUnion5 =
  | ManagerRetryResponseProviderAwsAlb5
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers5
  | ManagerRetryResponseProviderGkeGateway5
  | any;

/**
 * Shared Ingress route profile values.
 */
export type ManagerRetryResponseRouteIngress3 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb5
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers5
    | ManagerRetryResponseProviderGkeGateway5
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type ManagerRetryResponseRouteUnion3 =
  | ManagerRetryResponseRouteIngress3
  | ManagerRetryResponseRouteGateway3;

export type ManagerRetryResponseExposureGenerated2 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | ManagerRetryResponseCertificateTLSSecretRef3
    | ManagerRetryResponseCertificateManagedAcmImport3
    | ManagerRetryResponseCertificateAwsAcmArn3
    | ManagerRetryResponseCertificateManagedTLSSecret3
    | ManagerRetryResponseCertificateNone3;
  mode: ManagerRetryResponseModeGenerated2;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: ManagerRetryResponseRouteIngress3 | ManagerRetryResponseRouteGateway3;
};

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

export type ManagerRetryResponseExposureDisabled2 = {
  mode: ManagerRetryResponseModeDisabled2;
};

export type ManagerRetryResponseExposureUnion2 =
  | ManagerRetryResponseExposureCustom2
  | ManagerRetryResponseExposureGenerated2
  | ManagerRetryResponseExposureDisabled2
  | 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 ManagerRetryResponseKubernetes2 = {
  cluster?: ManagerRetryResponseCluster2 | any | null | undefined;
  exposure?:
    | ManagerRetryResponseExposureCustom2
    | ManagerRetryResponseExposureGenerated2
    | ManagerRetryResponseExposureDisabled2
    | any
    | null
    | undefined;
};

export type ManagerRetryResponseKubernetesUnion2 =
  | ManagerRetryResponseKubernetes2
  | any;

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

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

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

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

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

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

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

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

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

export type ManagerRetryResponseNetworkUseDefault2 = {
  type: ManagerRetryResponseTypeUseDefault2;
};

export type ManagerRetryResponseNetworkUnion2 =
  | ManagerRetryResponseNetworkByoVpcAws2
  | ManagerRetryResponseNetworkByoVpcGcp2
  | ManagerRetryResponseNetworkByoVnetAzure2
  | ManagerRetryResponseNetworkUseDefault2
  | ManagerRetryResponseNetworkCreate2
  | any;

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

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

/**
 * 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 ManagerRetryResponseStackSettings2 = {
  compute?: ManagerRetryResponseCompute2 | any | null | undefined;
  /**
   * Deployment model: how updates are delivered to the remote environment.
   */
  deploymentModel?: ManagerRetryResponseDeploymentModel2 | undefined;
  domains?: ManagerRetryResponseDomains2 | 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?: ManagerRetryResponseExternalBindings2 | null | undefined;
  /**
   * How heartbeat health checks are handled.
   */
  heartbeats?: ManagerRetryResponseHeartbeats2 | undefined;
  kubernetes?: ManagerRetryResponseKubernetes2 | any | null | undefined;
  network?:
    | ManagerRetryResponseNetworkByoVpcAws2
    | ManagerRetryResponseNetworkByoVpcGcp2
    | ManagerRetryResponseNetworkByoVnetAzure2
    | ManagerRetryResponseNetworkUseDefault2
    | ManagerRetryResponseNetworkCreate2
    | 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?: ManagerRetryResponseTelemetry2 | undefined;
  /**
   * How updates are delivered to the deployment.
   */
  updates?: ManagerRetryResponseUpdates2 | undefined;
};

export type ManagerRetryResponseSetupGoogleOauth = {
  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: ManagerRetryResponseStackSettings2;
};

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

export type ManagerRetryResponsePoolsAutoscale1 = {
  failureDomains?: ManagerRetryResponseFailureDomains2 | 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 ManagerRetryResponseFailureDomains1 = {
  /**
   * 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 ManagerRetryResponseFailureDomainsUnion1 =
  | ManagerRetryResponseFailureDomains1
  | any;

export type ManagerRetryResponsePoolsFixed1 = {
  failureDomains?: ManagerRetryResponseFailureDomains1 | 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 ManagerRetryResponsePoolsUnion1 =
  | ManagerRetryResponsePoolsFixed1
  | ManagerRetryResponsePoolsAutoscale1;

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

export type ManagerRetryResponseComputeUnion1 =
  | ManagerRetryResponseCompute1
  | any;

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

export type ManagerRetryResponseAws1 = {
  certificateArn: string;
};

export type ManagerRetryResponseAwsUnion1 = ManagerRetryResponseAws1 | any;

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

export type ManagerRetryResponseAzureUnion1 = ManagerRetryResponseAzure1 | any;

export type ManagerRetryResponseGcp1 = {
  certificateName: string;
};

export type ManagerRetryResponseGcpUnion1 = ManagerRetryResponseGcp1 | any;

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

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

export type ManagerRetryResponseDomainsKubernetesUnion1 =
  | ManagerRetryResponseDomainsKubernetes1
  | any;

/**
 * Platform-specific certificate references for custom domains.
 */
export type ManagerRetryResponseDomainsCertificate1 = {
  aws?: ManagerRetryResponseAws1 | any | null | undefined;
  azure?: ManagerRetryResponseAzure1 | any | null | undefined;
  gcp?: ManagerRetryResponseGcp1 | any | null | undefined;
  kubernetes?: ManagerRetryResponseDomainsKubernetes1 | any | null | undefined;
};

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

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

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

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

export type ManagerRetryResponsePublicEndpointTargetMachineAddresses1 = {
  mode: ManagerRetryResponseModeMachineAddresses1;
};

export type ManagerRetryResponsePublicEndpointTargetUnion1 =
  | ManagerRetryResponsePublicEndpointTargetLoadBalancer1
  | ManagerRetryResponsePublicEndpointTargetMachineAddresses1
  | 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 ManagerRetryResponseDomains1 = {
  /**
   * Custom domain configuration per resource ID.
   */
  customDomains?:
    | { [k: string]: ManagerRetryResponseCustomDomains1 }
    | null
    | undefined;
  publicEndpointTarget?:
    | ManagerRetryResponsePublicEndpointTargetLoadBalancer1
    | ManagerRetryResponsePublicEndpointTargetMachineAddresses1
    | any
    | null
    | undefined;
};

export type ManagerRetryResponseDomainsUnion1 =
  | ManagerRetryResponseDomains1
  | 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 ManagerRetryResponseExternalBindings1 = {};

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

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

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

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

export type ManagerRetryResponseClusterUnion1 =
  | ManagerRetryResponseCluster1
  | any;

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

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

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

export type ManagerRetryResponseCertificateManagedAcmImport2 = {
  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 ManagerRetryResponseCertificateTLSSecretRef2 = {
  /**
   * 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 ManagerRetryResponseCertificateUnion2 =
  | ManagerRetryResponseCertificateTLSSecretRef2
  | ManagerRetryResponseCertificateManagedAcmImport2
  | ManagerRetryResponseCertificateAwsAcmArn2
  | ManagerRetryResponseCertificateManagedTLSSecret2
  | ManagerRetryResponseCertificateNone2;

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

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb4 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum4;
  /**
   * 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 ManagerRetryResponseProviderUnion4 =
  | ManagerRetryResponseProviderAwsAlb4
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers4
  | ManagerRetryResponseProviderGkeGateway4
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type ManagerRetryResponseRouteGateway2 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb4
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers4
    | ManagerRetryResponseProviderGkeGateway4
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb3 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum3;
  /**
   * 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 ManagerRetryResponseProviderUnion3 =
  | ManagerRetryResponseProviderAwsAlb3
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers3
  | ManagerRetryResponseProviderGkeGateway3
  | any;

/**
 * Shared Ingress route profile values.
 */
export type ManagerRetryResponseRouteIngress2 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb3
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers3
    | ManagerRetryResponseProviderGkeGateway3
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type ManagerRetryResponseRouteUnion2 =
  | ManagerRetryResponseRouteIngress2
  | ManagerRetryResponseRouteGateway2;

export type ManagerRetryResponseExposureCustom1 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | ManagerRetryResponseCertificateTLSSecretRef2
    | ManagerRetryResponseCertificateManagedAcmImport2
    | ManagerRetryResponseCertificateAwsAcmArn2
    | ManagerRetryResponseCertificateManagedTLSSecret2
    | ManagerRetryResponseCertificateNone2;
  /**
   * Hostname routed by the Kubernetes public endpoint.
   */
  domain: string;
  mode: ManagerRetryResponseModeCustom1;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: ManagerRetryResponseRouteIngress2 | ManagerRetryResponseRouteGateway2;
};

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

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

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

export type ManagerRetryResponseCertificateManagedAcmImport1 = {
  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 ManagerRetryResponseCertificateTLSSecretRef1 = {
  /**
   * 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 ManagerRetryResponseCertificateUnion1 =
  | ManagerRetryResponseCertificateTLSSecretRef1
  | ManagerRetryResponseCertificateManagedAcmImport1
  | ManagerRetryResponseCertificateAwsAcmArn1
  | ManagerRetryResponseCertificateManagedTLSSecret1
  | ManagerRetryResponseCertificateNone1;

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

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb2 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum2;
  /**
   * 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 ManagerRetryResponseProviderUnion2 =
  | ManagerRetryResponseProviderAwsAlb2
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers2
  | ManagerRetryResponseProviderGkeGateway2
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type ManagerRetryResponseRouteGateway1 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb2
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers2
    | ManagerRetryResponseProviderGkeGateway2
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type ManagerRetryResponseProviderAwsAlb1 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: ManagerRetryResponseProviderAwsAlbEnum1;
  /**
   * 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 ManagerRetryResponseProviderUnion1 =
  | ManagerRetryResponseProviderAwsAlb1
  | ManagerRetryResponseProviderAzureApplicationGatewayForContainers1
  | ManagerRetryResponseProviderGkeGateway1
  | any;

/**
 * Shared Ingress route profile values.
 */
export type ManagerRetryResponseRouteIngress1 = {
  /**
   * 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?:
    | ManagerRetryResponseProviderAwsAlb1
    | ManagerRetryResponseProviderAzureApplicationGatewayForContainers1
    | ManagerRetryResponseProviderGkeGateway1
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type ManagerRetryResponseRouteUnion1 =
  | ManagerRetryResponseRouteIngress1
  | ManagerRetryResponseRouteGateway1;

export type ManagerRetryResponseExposureGenerated1 = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | ManagerRetryResponseCertificateTLSSecretRef1
    | ManagerRetryResponseCertificateManagedAcmImport1
    | ManagerRetryResponseCertificateAwsAcmArn1
    | ManagerRetryResponseCertificateManagedTLSSecret1
    | ManagerRetryResponseCertificateNone1;
  mode: ManagerRetryResponseModeGenerated1;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: ManagerRetryResponseRouteIngress1 | ManagerRetryResponseRouteGateway1;
};

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

export type ManagerRetryResponseExposureDisabled1 = {
  mode: ManagerRetryResponseModeDisabled1;
};

export type ManagerRetryResponseExposureUnion1 =
  | ManagerRetryResponseExposureCustom1
  | ManagerRetryResponseExposureGenerated1
  | ManagerRetryResponseExposureDisabled1
  | 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 ManagerRetryResponseKubernetes1 = {
  cluster?: ManagerRetryResponseCluster1 | any | null | undefined;
  exposure?:
    | ManagerRetryResponseExposureCustom1
    | ManagerRetryResponseExposureGenerated1
    | ManagerRetryResponseExposureDisabled1
    | any
    | null
    | undefined;
};

export type ManagerRetryResponseKubernetesUnion1 =
  | ManagerRetryResponseKubernetes1
  | any;

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

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

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

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

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

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

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

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

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

export type ManagerRetryResponseNetworkUseDefault1 = {
  type: ManagerRetryResponseTypeUseDefault1;
};

export type ManagerRetryResponseNetworkUnion1 =
  | ManagerRetryResponseNetworkByoVpcAws1
  | ManagerRetryResponseNetworkByoVpcGcp1
  | ManagerRetryResponseNetworkByoVnetAzure1
  | ManagerRetryResponseNetworkUseDefault1
  | ManagerRetryResponseNetworkCreate1
  | any;

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

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

/**
 * 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 ManagerRetryResponseStackSettings1 = {
  compute?: ManagerRetryResponseCompute1 | any | null | undefined;
  /**
   * Deployment model: how updates are delivered to the remote environment.
   */
  deploymentModel?: ManagerRetryResponseDeploymentModel1 | undefined;
  domains?: ManagerRetryResponseDomains1 | 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?: ManagerRetryResponseExternalBindings1 | null | undefined;
  /**
   * How heartbeat health checks are handled.
   */
  heartbeats?: ManagerRetryResponseHeartbeats1 | undefined;
  kubernetes?: ManagerRetryResponseKubernetes1 | any | null | undefined;
  network?:
    | ManagerRetryResponseNetworkByoVpcAws1
    | ManagerRetryResponseNetworkByoVpcGcp1
    | ManagerRetryResponseNetworkByoVnetAzure1
    | ManagerRetryResponseNetworkUseDefault1
    | ManagerRetryResponseNetworkCreate1
    | 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?: ManagerRetryResponseTelemetry1 | undefined;
  /**
   * How updates are delivered to the deployment.
   */
  updates?: ManagerRetryResponseUpdates1 | undefined;
};

export type ManagerRetryResponseSetupCloudformation = {
  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: ManagerRetryResponseStackSettings1;
};

export type ManagerRetryResponseSetupUnion =
  | ManagerRetryResponseSetupCloudformation
  | ManagerRetryResponseSetupGoogleOauth
  | ManagerRetryResponseSetupTerraform;

export const ModeSetup = {
  Setup: "setup",
} as const;
export type ModeSetup = ClosedEnum<typeof ModeSetup>;

export type ManagerRetryResponseSetup = {
  managerId: string;
  setupStatus: "pending";
  setupToken: string;
  setupTokenId: string;
  deploymentLink: string;
  setupConfig: ManagerRetryResponseSetupConfig;
  setup:
    | ManagerRetryResponseSetupCloudformation
    | ManagerRetryResponseSetupGoogleOauth
    | ManagerRetryResponseSetupTerraform;
  mode: ModeSetup;
};

export type ManagerRetryResponse =
  | ManagerRetryResponseSetup
  | ManagerRetryDeploymentResponse;

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseConfiguration$inboundSchema: z.ZodType<
  ManagerRetryResponseConfiguration,
  unknown
> = z.object({
  allowedProviders: z.array(ManagerRetryResponseAllowedProvider$inboundSchema)
    .optional(),
  providerAllowlist: z.array(
    ManagerRetryResponseProviderAllowlist$inboundSchema,
  ).optional(),
  modelRequirements: z.array(
    z.lazy(() => ManagerRetryResponseModelRequirement$inboundSchema),
  ).optional(),
});

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

/** @internal */
export const ManagerRetryResponseItem$inboundSchema: z.ZodType<
  ManagerRetryResponseItem,
  unknown
> = z.object({
  item: ManagerRetryResponseItemEnum$inboundSchema,
  source: z.union([
    z.lazy(() => ManagerRetryResponseSourceProjectRelease$inboundSchema),
    z.lazy(() => ManagerRetryResponseSourceBuiltIn$inboundSchema),
  ]),
  required: z.boolean(),
  configuration: z.lazy(() => ManagerRetryResponseConfiguration$inboundSchema)
    .optional(),
});

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

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

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

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

/** @internal */
export const ManagerRetryResponseSetupConfig$inboundSchema: z.ZodType<
  ManagerRetryResponseSetupConfig,
  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(() => ManagerRetryResponseItem$inboundSchema))
    .optional(),
  publicSubdomain: z.string().optional(),
  environmentVariables: z.array(
    z.lazy(() => ManagerRetryResponseEnvironmentVariable$inboundSchema),
  ),
});

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

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

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

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

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

/** @internal */
export const ManagerRetryResponsePoolsAutoscale3$inboundSchema: z.ZodType<
  ManagerRetryResponsePoolsAutoscale3,
  unknown
> = z.object({
  failure_domains: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseFailureDomains6$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 managerRetryResponsePoolsAutoscale3FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponsePoolsAutoscale3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      ManagerRetryResponsePoolsAutoscale3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponsePoolsAutoscale3' from JSON`,
  );
}

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

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

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

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

/** @internal */
export const ManagerRetryResponsePoolsFixed3$inboundSchema: z.ZodType<
  ManagerRetryResponsePoolsFixed3,
  unknown
> = z.object({
  failure_domains: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseFailureDomains5$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 managerRetryResponsePoolsFixed3FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponsePoolsFixed3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ManagerRetryResponsePoolsFixed3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponsePoolsFixed3' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseDomainsCertificate3$inboundSchema: z.ZodType<
  ManagerRetryResponseDomainsCertificate3,
  unknown
> = z.object({
  aws: z.nullable(
    z.union([z.lazy(() => ManagerRetryResponseAws3$inboundSchema), z.any()]),
  ).optional(),
  azure: z.nullable(
    z.union([z.lazy(() => ManagerRetryResponseAzure3$inboundSchema), z.any()]),
  ).optional(),
  gcp: z.nullable(
    z.union([z.lazy(() => ManagerRetryResponseGcp3$inboundSchema), z.any()]),
  ).optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseDomainsKubernetes3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseCloud3$inboundSchema: z.ZodType<
  ManagerRetryResponseCloud3,
  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 managerRetryResponseCloud3FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponseCloud3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ManagerRetryResponseCloud3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponseCloud3' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseCertificateUnion6$inboundSchema: z.ZodType<
  ManagerRetryResponseCertificateUnion6,
  unknown
> = z.union([
  z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef6$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedAcmImport6$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn6$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedTLSSecret6$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateNone6$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteGateway6$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteGateway6,
  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(() => ManagerRetryResponseProviderAwsAlb12$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers12$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway12$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteIngress6$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteIngress6,
  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(() => ManagerRetryResponseProviderAwsAlb11$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers11$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway11$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

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

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

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

/** @internal */
export const ManagerRetryResponseExposureCustom3$inboundSchema: z.ZodType<
  ManagerRetryResponseExposureCustom3,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef6$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedAcmImport6$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn6$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedTLSSecret6$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateNone6$inboundSchema),
  ]),
  domain: z.string(),
  mode: ManagerRetryResponseModeCustom3$inboundSchema,
  route: z.union([
    z.lazy(() => ManagerRetryResponseRouteIngress6$inboundSchema),
    z.lazy(() => ManagerRetryResponseRouteGateway6$inboundSchema),
  ]),
});

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseCertificateUnion5$inboundSchema: z.ZodType<
  ManagerRetryResponseCertificateUnion5,
  unknown
> = z.union([
  z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef5$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedAcmImport5$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn5$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedTLSSecret5$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateNone5$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteGateway5$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteGateway5,
  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(() => ManagerRetryResponseProviderAwsAlb10$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers10$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway10$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteIngress5$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteIngress5,
  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(() => ManagerRetryResponseProviderAwsAlb9$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers9$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway9$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

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

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

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

/** @internal */
export const ManagerRetryResponseExposureGenerated3$inboundSchema: z.ZodType<
  ManagerRetryResponseExposureGenerated3,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef5$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedAcmImport5$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn5$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedTLSSecret5$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateNone5$inboundSchema),
  ]),
  mode: ManagerRetryResponseModeGenerated3$inboundSchema,
  route: z.union([
    z.lazy(() => ManagerRetryResponseRouteIngress5$inboundSchema),
    z.lazy(() => ManagerRetryResponseRouteGateway5$inboundSchema),
  ]),
});

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseKubernetes3$inboundSchema: z.ZodType<
  ManagerRetryResponseKubernetes3,
  unknown
> = z.object({
  cluster: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseCluster3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  exposure: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseExposureCustom3$inboundSchema),
      z.lazy(() => ManagerRetryResponseExposureGenerated3$inboundSchema),
      z.lazy(() => ManagerRetryResponseExposureDisabled3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

/** @internal */
export const ManagerRetryResponseNetworkByoVnetAzure3$inboundSchema: z.ZodType<
  ManagerRetryResponseNetworkByoVnetAzure3,
  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: ManagerRetryResponseTypeByoVnetAzure3$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 managerRetryResponseNetworkByoVnetAzure3FromJSON(
  jsonString: string,
): SafeParseResult<
  ManagerRetryResponseNetworkByoVnetAzure3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      ManagerRetryResponseNetworkByoVnetAzure3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'ManagerRetryResponseNetworkByoVnetAzure3' from JSON`,
  );
}

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

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

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

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

/** @internal */
export const ManagerRetryResponseNetworkByoVpcAws3$inboundSchema: z.ZodType<
  ManagerRetryResponseNetworkByoVpcAws3,
  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: ManagerRetryResponseTypeByoVpcAws3$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 managerRetryResponseNetworkByoVpcAws3FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponseNetworkByoVpcAws3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      ManagerRetryResponseNetworkByoVpcAws3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponseNetworkByoVpcAws3' from JSON`,
  );
}

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseNetworkUnion3$inboundSchema: z.ZodType<
  ManagerRetryResponseNetworkUnion3,
  unknown
> = z.union([
  z.lazy(() => ManagerRetryResponseNetworkByoVpcAws3$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkByoVpcGcp3$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkByoVnetAzure3$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkUseDefault3$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkCreate3$inboundSchema),
  z.any(),
]);

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

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

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

/** @internal */
export const ManagerRetryResponseStackSettings3$inboundSchema: z.ZodType<
  ManagerRetryResponseStackSettings3,
  unknown
> = z.object({
  compute: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseCompute3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  deploymentModel: ManagerRetryResponseDeploymentModel3$inboundSchema
    .optional(),
  domains: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseDomains3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  externalBindings: z.nullable(
    z.lazy(() => ManagerRetryResponseExternalBindings3$inboundSchema),
  ).optional(),
  heartbeats: ManagerRetryResponseHeartbeats3$inboundSchema.optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseKubernetes3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  network: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseNetworkByoVpcAws3$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkByoVpcGcp3$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkByoVnetAzure3$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkUseDefault3$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkCreate3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  publicEndpoints: z.nullable(
    z.record(z.string(), z.record(z.string(), z.string())),
  ).optional(),
  telemetry: ManagerRetryResponseTelemetry3$inboundSchema.optional(),
  updates: ManagerRetryResponseUpdates3$inboundSchema.optional(),
});

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

/** @internal */
export const ManagerRetryResponseSetupTerraform$inboundSchema: z.ZodType<
  ManagerRetryResponseSetupTerraform,
  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(() => ManagerRetryResponseStackSettings3$inboundSchema),
});

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

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

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

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

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

/** @internal */
export const ManagerRetryResponsePoolsAutoscale2$inboundSchema: z.ZodType<
  ManagerRetryResponsePoolsAutoscale2,
  unknown
> = z.object({
  failure_domains: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseFailureDomains4$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 managerRetryResponsePoolsAutoscale2FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponsePoolsAutoscale2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      ManagerRetryResponsePoolsAutoscale2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponsePoolsAutoscale2' from JSON`,
  );
}

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

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

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

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

/** @internal */
export const ManagerRetryResponsePoolsFixed2$inboundSchema: z.ZodType<
  ManagerRetryResponsePoolsFixed2,
  unknown
> = z.object({
  failure_domains: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseFailureDomains3$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 managerRetryResponsePoolsFixed2FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponsePoolsFixed2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ManagerRetryResponsePoolsFixed2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponsePoolsFixed2' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseDomainsCertificate2$inboundSchema: z.ZodType<
  ManagerRetryResponseDomainsCertificate2,
  unknown
> = z.object({
  aws: z.nullable(
    z.union([z.lazy(() => ManagerRetryResponseAws2$inboundSchema), z.any()]),
  ).optional(),
  azure: z.nullable(
    z.union([z.lazy(() => ManagerRetryResponseAzure2$inboundSchema), z.any()]),
  ).optional(),
  gcp: z.nullable(
    z.union([z.lazy(() => ManagerRetryResponseGcp2$inboundSchema), z.any()]),
  ).optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseDomainsKubernetes2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseCloud2$inboundSchema: z.ZodType<
  ManagerRetryResponseCloud2,
  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 managerRetryResponseCloud2FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponseCloud2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ManagerRetryResponseCloud2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponseCloud2' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseCertificateUnion4$inboundSchema: z.ZodType<
  ManagerRetryResponseCertificateUnion4,
  unknown
> = z.union([
  z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef4$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedAcmImport4$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn4$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedTLSSecret4$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateNone4$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteGateway4$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteGateway4,
  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(() => ManagerRetryResponseProviderAwsAlb8$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers8$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway8$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteIngress4$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteIngress4,
  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(() => ManagerRetryResponseProviderAwsAlb7$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers7$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway7$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

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

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

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

/** @internal */
export const ManagerRetryResponseExposureCustom2$inboundSchema: z.ZodType<
  ManagerRetryResponseExposureCustom2,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef4$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedAcmImport4$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn4$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedTLSSecret4$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateNone4$inboundSchema),
  ]),
  domain: z.string(),
  mode: ManagerRetryResponseModeCustom2$inboundSchema,
  route: z.union([
    z.lazy(() => ManagerRetryResponseRouteIngress4$inboundSchema),
    z.lazy(() => ManagerRetryResponseRouteGateway4$inboundSchema),
  ]),
});

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseCertificateUnion3$inboundSchema: z.ZodType<
  ManagerRetryResponseCertificateUnion3,
  unknown
> = z.union([
  z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef3$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedAcmImport3$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn3$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedTLSSecret3$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateNone3$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteGateway3$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteGateway3,
  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(() => ManagerRetryResponseProviderAwsAlb6$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers6$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway6$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteIngress3$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteIngress3,
  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(() => ManagerRetryResponseProviderAwsAlb5$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers5$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway5$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

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

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

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

/** @internal */
export const ManagerRetryResponseExposureGenerated2$inboundSchema: z.ZodType<
  ManagerRetryResponseExposureGenerated2,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef3$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedAcmImport3$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn3$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedTLSSecret3$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateNone3$inboundSchema),
  ]),
  mode: ManagerRetryResponseModeGenerated2$inboundSchema,
  route: z.union([
    z.lazy(() => ManagerRetryResponseRouteIngress3$inboundSchema),
    z.lazy(() => ManagerRetryResponseRouteGateway3$inboundSchema),
  ]),
});

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseKubernetes2$inboundSchema: z.ZodType<
  ManagerRetryResponseKubernetes2,
  unknown
> = z.object({
  cluster: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseCluster2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  exposure: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseExposureCustom2$inboundSchema),
      z.lazy(() => ManagerRetryResponseExposureGenerated2$inboundSchema),
      z.lazy(() => ManagerRetryResponseExposureDisabled2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

/** @internal */
export const ManagerRetryResponseNetworkByoVnetAzure2$inboundSchema: z.ZodType<
  ManagerRetryResponseNetworkByoVnetAzure2,
  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: ManagerRetryResponseTypeByoVnetAzure2$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 managerRetryResponseNetworkByoVnetAzure2FromJSON(
  jsonString: string,
): SafeParseResult<
  ManagerRetryResponseNetworkByoVnetAzure2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      ManagerRetryResponseNetworkByoVnetAzure2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'ManagerRetryResponseNetworkByoVnetAzure2' from JSON`,
  );
}

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

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

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

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

/** @internal */
export const ManagerRetryResponseNetworkByoVpcAws2$inboundSchema: z.ZodType<
  ManagerRetryResponseNetworkByoVpcAws2,
  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: ManagerRetryResponseTypeByoVpcAws2$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 managerRetryResponseNetworkByoVpcAws2FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponseNetworkByoVpcAws2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      ManagerRetryResponseNetworkByoVpcAws2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponseNetworkByoVpcAws2' from JSON`,
  );
}

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseNetworkUnion2$inboundSchema: z.ZodType<
  ManagerRetryResponseNetworkUnion2,
  unknown
> = z.union([
  z.lazy(() => ManagerRetryResponseNetworkByoVpcAws2$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkByoVpcGcp2$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkByoVnetAzure2$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkUseDefault2$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkCreate2$inboundSchema),
  z.any(),
]);

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

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

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

/** @internal */
export const ManagerRetryResponseStackSettings2$inboundSchema: z.ZodType<
  ManagerRetryResponseStackSettings2,
  unknown
> = z.object({
  compute: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseCompute2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  deploymentModel: ManagerRetryResponseDeploymentModel2$inboundSchema
    .optional(),
  domains: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseDomains2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  externalBindings: z.nullable(
    z.lazy(() => ManagerRetryResponseExternalBindings2$inboundSchema),
  ).optional(),
  heartbeats: ManagerRetryResponseHeartbeats2$inboundSchema.optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseKubernetes2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  network: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseNetworkByoVpcAws2$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkByoVpcGcp2$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkByoVnetAzure2$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkUseDefault2$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkCreate2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  publicEndpoints: z.nullable(
    z.record(z.string(), z.record(z.string(), z.string())),
  ).optional(),
  telemetry: ManagerRetryResponseTelemetry2$inboundSchema.optional(),
  updates: ManagerRetryResponseUpdates2$inboundSchema.optional(),
});

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponsePoolsAutoscale1$inboundSchema: z.ZodType<
  ManagerRetryResponsePoolsAutoscale1,
  unknown
> = z.object({
  failure_domains: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseFailureDomains2$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 managerRetryResponsePoolsAutoscale1FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponsePoolsAutoscale1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      ManagerRetryResponsePoolsAutoscale1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponsePoolsAutoscale1' from JSON`,
  );
}

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

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

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

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

/** @internal */
export const ManagerRetryResponsePoolsFixed1$inboundSchema: z.ZodType<
  ManagerRetryResponsePoolsFixed1,
  unknown
> = z.object({
  failure_domains: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseFailureDomains1$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 managerRetryResponsePoolsFixed1FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponsePoolsFixed1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ManagerRetryResponsePoolsFixed1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponsePoolsFixed1' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseDomainsCertificate1$inboundSchema: z.ZodType<
  ManagerRetryResponseDomainsCertificate1,
  unknown
> = z.object({
  aws: z.nullable(
    z.union([z.lazy(() => ManagerRetryResponseAws1$inboundSchema), z.any()]),
  ).optional(),
  azure: z.nullable(
    z.union([z.lazy(() => ManagerRetryResponseAzure1$inboundSchema), z.any()]),
  ).optional(),
  gcp: z.nullable(
    z.union([z.lazy(() => ManagerRetryResponseGcp1$inboundSchema), z.any()]),
  ).optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseDomainsKubernetes1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseCloud1$inboundSchema: z.ZodType<
  ManagerRetryResponseCloud1,
  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 managerRetryResponseCloud1FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponseCloud1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ManagerRetryResponseCloud1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponseCloud1' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseCertificateUnion2$inboundSchema: z.ZodType<
  ManagerRetryResponseCertificateUnion2,
  unknown
> = z.union([
  z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef2$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedAcmImport2$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn2$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedTLSSecret2$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateNone2$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteGateway2$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteGateway2,
  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(() => ManagerRetryResponseProviderAwsAlb4$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers4$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway4$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteIngress2$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteIngress2,
  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(() => ManagerRetryResponseProviderAwsAlb3$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers3$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway3$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

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

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

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

/** @internal */
export const ManagerRetryResponseExposureCustom1$inboundSchema: z.ZodType<
  ManagerRetryResponseExposureCustom1,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef2$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedAcmImport2$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn2$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedTLSSecret2$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateNone2$inboundSchema),
  ]),
  domain: z.string(),
  mode: ManagerRetryResponseModeCustom1$inboundSchema,
  route: z.union([
    z.lazy(() => ManagerRetryResponseRouteIngress2$inboundSchema),
    z.lazy(() => ManagerRetryResponseRouteGateway2$inboundSchema),
  ]),
});

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseCertificateUnion1$inboundSchema: z.ZodType<
  ManagerRetryResponseCertificateUnion1,
  unknown
> = z.union([
  z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef1$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedAcmImport1$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn1$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateManagedTLSSecret1$inboundSchema),
  z.lazy(() => ManagerRetryResponseCertificateNone1$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteGateway1$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteGateway1,
  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(() => ManagerRetryResponseProviderAwsAlb2$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers2$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway2$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("gateway"),
});

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseRouteIngress1$inboundSchema: z.ZodType<
  ManagerRetryResponseRouteIngress1,
  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(() => ManagerRetryResponseProviderAwsAlb1$inboundSchema),
      z.lazy(() =>
        ManagerRetryResponseProviderAzureApplicationGatewayForContainers1$inboundSchema
      ),
      z.lazy(() => ManagerRetryResponseProviderGkeGateway1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  routeApi: z.literal("ingress"),
});

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

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

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

/** @internal */
export const ManagerRetryResponseExposureGenerated1$inboundSchema: z.ZodType<
  ManagerRetryResponseExposureGenerated1,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => ManagerRetryResponseCertificateTLSSecretRef1$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedAcmImport1$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateAwsAcmArn1$inboundSchema),
    z.lazy(() =>
      ManagerRetryResponseCertificateManagedTLSSecret1$inboundSchema
    ),
    z.lazy(() => ManagerRetryResponseCertificateNone1$inboundSchema),
  ]),
  mode: ManagerRetryResponseModeGenerated1$inboundSchema,
  route: z.union([
    z.lazy(() => ManagerRetryResponseRouteIngress1$inboundSchema),
    z.lazy(() => ManagerRetryResponseRouteGateway1$inboundSchema),
  ]),
});

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseKubernetes1$inboundSchema: z.ZodType<
  ManagerRetryResponseKubernetes1,
  unknown
> = z.object({
  cluster: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseCluster1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  exposure: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseExposureCustom1$inboundSchema),
      z.lazy(() => ManagerRetryResponseExposureGenerated1$inboundSchema),
      z.lazy(() => ManagerRetryResponseExposureDisabled1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

/** @internal */
export const ManagerRetryResponseNetworkByoVnetAzure1$inboundSchema: z.ZodType<
  ManagerRetryResponseNetworkByoVnetAzure1,
  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: ManagerRetryResponseTypeByoVnetAzure1$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 managerRetryResponseNetworkByoVnetAzure1FromJSON(
  jsonString: string,
): SafeParseResult<
  ManagerRetryResponseNetworkByoVnetAzure1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      ManagerRetryResponseNetworkByoVnetAzure1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'ManagerRetryResponseNetworkByoVnetAzure1' from JSON`,
  );
}

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

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

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

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

/** @internal */
export const ManagerRetryResponseNetworkByoVpcAws1$inboundSchema: z.ZodType<
  ManagerRetryResponseNetworkByoVpcAws1,
  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: ManagerRetryResponseTypeByoVpcAws1$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 managerRetryResponseNetworkByoVpcAws1FromJSON(
  jsonString: string,
): SafeParseResult<ManagerRetryResponseNetworkByoVpcAws1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      ManagerRetryResponseNetworkByoVpcAws1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ManagerRetryResponseNetworkByoVpcAws1' from JSON`,
  );
}

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

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

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

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

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

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

/** @internal */
export const ManagerRetryResponseNetworkUnion1$inboundSchema: z.ZodType<
  ManagerRetryResponseNetworkUnion1,
  unknown
> = z.union([
  z.lazy(() => ManagerRetryResponseNetworkByoVpcAws1$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkByoVpcGcp1$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkByoVnetAzure1$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkUseDefault1$inboundSchema),
  z.lazy(() => ManagerRetryResponseNetworkCreate1$inboundSchema),
  z.any(),
]);

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

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

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

/** @internal */
export const ManagerRetryResponseStackSettings1$inboundSchema: z.ZodType<
  ManagerRetryResponseStackSettings1,
  unknown
> = z.object({
  compute: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseCompute1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  deploymentModel: ManagerRetryResponseDeploymentModel1$inboundSchema
    .optional(),
  domains: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseDomains1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  externalBindings: z.nullable(
    z.lazy(() => ManagerRetryResponseExternalBindings1$inboundSchema),
  ).optional(),
  heartbeats: ManagerRetryResponseHeartbeats1$inboundSchema.optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseKubernetes1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  network: z.nullable(
    z.union([
      z.lazy(() => ManagerRetryResponseNetworkByoVpcAws1$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkByoVpcGcp1$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkByoVnetAzure1$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkUseDefault1$inboundSchema),
      z.lazy(() => ManagerRetryResponseNetworkCreate1$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  publicEndpoints: z.nullable(
    z.record(z.string(), z.record(z.string(), z.string())),
  ).optional(),
  telemetry: ManagerRetryResponseTelemetry1$inboundSchema.optional(),
  updates: ManagerRetryResponseUpdates1$inboundSchema.optional(),
});

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

/** @internal */
export const ManagerRetryResponseSetupCloudformation$inboundSchema: z.ZodType<
  ManagerRetryResponseSetupCloudformation,
  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(() => ManagerRetryResponseStackSettings1$inboundSchema),
});

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

/** @internal */
export const ManagerRetryResponseSetupUnion$inboundSchema: z.ZodType<
  ManagerRetryResponseSetupUnion,
  unknown
> = z.union([
  z.lazy(() => ManagerRetryResponseSetupCloudformation$inboundSchema),
  z.lazy(() => ManagerRetryResponseSetupGoogleOauth$inboundSchema),
  z.lazy(() => ManagerRetryResponseSetupTerraform$inboundSchema),
]);

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

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

/** @internal */
export const ManagerRetryResponseSetup$inboundSchema: z.ZodType<
  ManagerRetryResponseSetup,
  unknown
> = z.object({
  managerId: z.string(),
  setupStatus: z.literal("pending"),
  setupToken: z.string(),
  setupTokenId: z.string(),
  deploymentLink: z.string(),
  setupConfig: z.lazy(() => ManagerRetryResponseSetupConfig$inboundSchema),
  setup: z.union([
    z.lazy(() => ManagerRetryResponseSetupCloudformation$inboundSchema),
    z.lazy(() => ManagerRetryResponseSetupGoogleOauth$inboundSchema),
    z.lazy(() => ManagerRetryResponseSetupTerraform$inboundSchema),
  ]),
  mode: ModeSetup$inboundSchema,
});

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

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

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