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

import * as z from "zod/v4";
import { remap as remap$ } from "../lib/primitives.js";
import {
  collectExtraKeys as collectExtraKeys$,
  safeParse,
} from "../lib/schemas.js";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import {
  DeploymentPurpose,
  DeploymentPurpose$inboundSchema,
} from "./deploymentpurpose.js";
import {
  DeploymentUpdateOperationSummary,
  DeploymentUpdateOperationSummary$inboundSchema,
} from "./deploymentupdateoperationsummary.js";
import { SDKValidationError } from "./errors/sdkvalidationerror.js";
import {
  OperatorCapabilityReport,
  OperatorCapabilityReport$inboundSchema,
} from "./operatorcapabilityreport.js";
import {
  ReportedOperation,
  ReportedOperation$inboundSchema,
} from "./reportedoperation.js";

/**
 * Deployment status in the deployment lifecycle.
 *
 * @remarks
 *
 * For observe-only deployments with no release or stack state, `Running`
 * means the Operator is attached. Connectivity comes from `lastHeartbeatAt`;
 * resource health comes from inventory and resource heartbeat data.
 */
export const DeploymentStatus = {
  Pending: "pending",
  PreflightsFailed: "preflights-failed",
  InitialSetup: "initial-setup",
  InitialSetupFailed: "initial-setup-failed",
  Provisioning: "provisioning",
  WaitingForMachines: "waiting-for-machines",
  ProvisioningFailed: "provisioning-failed",
  Running: "running",
  RefreshFailed: "refresh-failed",
  UpdatePending: "update-pending",
  Updating: "updating",
  UpdateFailed: "update-failed",
  DeletePending: "delete-pending",
  Deleting: "deleting",
  DeleteFailed: "delete-failed",
  TeardownRequired: "teardown-required",
  TeardownFailed: "teardown-failed",
  Deleted: "deleted",
  Error: "error",
} as const;
/**
 * Deployment status in the deployment lifecycle.
 *
 * @remarks
 *
 * For observe-only deployments with no release or stack state, `Running`
 * means the Operator is attached. Connectivity comes from `lastHeartbeatAt`;
 * resource health comes from inventory and resource heartbeat data.
 */
export type DeploymentStatus = ClosedEnum<typeof DeploymentStatus>;

/**
 * Target platform for the deployment
 */
export const DeploymentPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Local: "local",
  Test: "test",
} as const;
/**
 * Target platform for the deployment
 */
export type DeploymentPlatform = ClosedEnum<typeof DeploymentPlatform>;

/**
 * Underlying cloud platform for Kubernetes deployments.
 */
export const DeploymentBasePlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
} as const;
/**
 * Underlying cloud platform for Kubernetes deployments.
 */
export type DeploymentBasePlatform = ClosedEnum<typeof DeploymentBasePlatform>;

export const DeploymentPlatformTest = {
  Test: "test",
} as const;
export type DeploymentPlatformTest = ClosedEnum<typeof DeploymentPlatformTest>;

/**
 * Test platform environment information (mock)
 */
export type DeploymentEnvironmentInfoTest = {
  /**
   * Test identifier for this environment
   */
  testId: string;
  platform: DeploymentPlatformTest;
};

export const DeploymentPlatformLocal = {
  Local: "local",
} as const;
export type DeploymentPlatformLocal = ClosedEnum<
  typeof DeploymentPlatformLocal
>;

/**
 * Local platform environment information
 */
export type DeploymentEnvironmentInfoLocal = {
  /**
   * Architecture (e.g., "x86_64", "aarch64")
   */
  arch: string;
  /**
   * Hostname of the machine running the deployment
   */
  hostname: string;
  /**
   * Operating system (e.g., "linux", "macos", "windows")
   */
  os: string;
  platform: DeploymentPlatformLocal;
};

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

/**
 * Azure-specific environment information
 */
export type DeploymentEnvironmentInfoAzure = {
  /**
   * Azure location/region
   */
  location: string;
  /**
   * Azure subscription ID
   */
  subscriptionId: string;
  /**
   * Azure tenant ID
   */
  tenantId: string;
  platform: DeploymentPlatformAzure;
};

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

/**
 * GCP-specific environment information
 */
export type DeploymentEnvironmentInfoGcp = {
  /**
   * GCP project ID (e.g., "my-project")
   */
  projectId: string;
  /**
   * GCP project number (e.g., "123456789012")
   */
  projectNumber: string;
  /**
   * GCP region
   */
  region: string;
  platform: DeploymentPlatformGcp;
};

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

/**
 * AWS-specific environment information
 */
export type DeploymentEnvironmentInfoAws = {
  /**
   * AWS account ID
   */
  accountId: string;
  /**
   * AWS region
   */
  region: string;
  platform: DeploymentPlatformAws;
};

/**
 * Cloud environment information
 */
export type DeploymentEnvironmentInfoUnion =
  | DeploymentEnvironmentInfoGcp
  | DeploymentEnvironmentInfoAzure
  | DeploymentEnvironmentInfoLocal
  | DeploymentEnvironmentInfoAws
  | DeploymentEnvironmentInfoTest
  | any;

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

export type DeploymentPoolsAutoscale = {
  failureDomains?: DeploymentFailureDomains2 | 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 DeploymentFailureDomains1 = {
  /**
   * 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 DeploymentFailureDomainsUnion1 = DeploymentFailureDomains1 | any;

export type DeploymentPoolsFixed = {
  failureDomains?: DeploymentFailureDomains1 | 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 DeploymentPoolsUnion =
  | DeploymentPoolsFixed
  | DeploymentPoolsAutoscale;

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

export type DeploymentComputeUnion = DeploymentCompute | any;

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

export type DeploymentAws = {
  certificateArn: string;
};

export type DeploymentAwsUnion = DeploymentAws | any;

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

export type DeploymentAzureUnion = DeploymentAzureStackSettings | any;

export type DeploymentGcpStackSettings = {
  certificateName: string;
};

export type DeploymentGcpUnion = DeploymentGcpStackSettings | any;

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

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

export type DeploymentDomainsKubernetesUnion =
  | DeploymentDomainsKubernetes
  | any;

/**
 * Platform-specific certificate references for custom domains.
 */
export type DeploymentDomainsCertificate = {
  aws?: DeploymentAws | any | null | undefined;
  azure?: DeploymentAzureStackSettings | any | null | undefined;
  gcp?: DeploymentGcpStackSettings | any | null | undefined;
  kubernetes?: DeploymentDomainsKubernetes | any | null | undefined;
};

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

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

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

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

export type DeploymentPublicEndpointTargetMachineAddresses = {
  mode: DeploymentModeMachineAddresses;
};

export type DeploymentPublicEndpointTargetUnion =
  | DeploymentPublicEndpointTargetLoadBalancer
  | DeploymentPublicEndpointTargetMachineAddresses
  | 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 DeploymentDomains = {
  /**
   * Custom domain configuration per resource ID.
   */
  customDomains?: { [k: string]: DeploymentCustomDomains } | null | undefined;
  publicEndpointTarget?:
    | DeploymentPublicEndpointTargetLoadBalancer
    | DeploymentPublicEndpointTargetMachineAddresses
    | any
    | null
    | undefined;
};

export type DeploymentDomainsUnion = DeploymentDomains | 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 DeploymentExternalBindings = {};

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

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

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

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

export type DeploymentClusterUnion = DeploymentCluster | any;

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

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

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

export type DeploymentCertificateManagedAcmImport2 = {
  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 DeploymentCertificateTLSSecretRef2 = {
  /**
   * 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 DeploymentCertificateUnion2 =
  | DeploymentCertificateTLSSecretRef2
  | DeploymentCertificateManagedAcmImport2
  | DeploymentCertificateAwsAcmArn2
  | DeploymentCertificateManagedTLSSecret2
  | DeploymentCertificateNone2;

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

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

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

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

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

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

export type DeploymentProviderAwsAlb4 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: DeploymentProviderAwsAlbEnum4;
  /**
   * 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 DeploymentProviderUnion4 =
  | DeploymentProviderAwsAlb4
  | DeploymentProviderAzureApplicationGatewayForContainers4
  | DeploymentProviderGkeGateway4
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type DeploymentRouteGateway2 = {
  /**
   * 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?:
    | DeploymentProviderAwsAlb4
    | DeploymentProviderAzureApplicationGatewayForContainers4
    | DeploymentProviderGkeGateway4
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type DeploymentProviderAwsAlb3 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: DeploymentProviderAwsAlbEnum3;
  /**
   * 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 DeploymentProviderUnion3 =
  | DeploymentProviderAwsAlb3
  | DeploymentProviderAzureApplicationGatewayForContainers3
  | DeploymentProviderGkeGateway3
  | any;

/**
 * Shared Ingress route profile values.
 */
export type DeploymentRouteIngress2 = {
  /**
   * 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?:
    | DeploymentProviderAwsAlb3
    | DeploymentProviderAzureApplicationGatewayForContainers3
    | DeploymentProviderGkeGateway3
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type DeploymentRouteUnion2 =
  | DeploymentRouteIngress2
  | DeploymentRouteGateway2;

export type DeploymentExposureCustom = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | DeploymentCertificateTLSSecretRef2
    | DeploymentCertificateManagedAcmImport2
    | DeploymentCertificateAwsAcmArn2
    | DeploymentCertificateManagedTLSSecret2
    | DeploymentCertificateNone2;
  /**
   * Hostname routed by the Kubernetes public endpoint.
   */
  domain: string;
  mode: DeploymentModeCustom;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: DeploymentRouteIngress2 | DeploymentRouteGateway2;
};

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

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

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

export type DeploymentCertificateManagedAcmImport1 = {
  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 DeploymentCertificateTLSSecretRef1 = {
  /**
   * 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 DeploymentCertificateUnion1 =
  | DeploymentCertificateTLSSecretRef1
  | DeploymentCertificateManagedAcmImport1
  | DeploymentCertificateAwsAcmArn1
  | DeploymentCertificateManagedTLSSecret1
  | DeploymentCertificateNone1;

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

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

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

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

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

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

export type DeploymentProviderAwsAlb2 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: DeploymentProviderAwsAlbEnum2;
  /**
   * 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 DeploymentProviderUnion2 =
  | DeploymentProviderAwsAlb2
  | DeploymentProviderAzureApplicationGatewayForContainers2
  | DeploymentProviderGkeGateway2
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type DeploymentRouteGateway1 = {
  /**
   * 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?:
    | DeploymentProviderAwsAlb2
    | DeploymentProviderAzureApplicationGatewayForContainers2
    | DeploymentProviderGkeGateway2
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type DeploymentProviderAwsAlb1 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: DeploymentProviderAwsAlbEnum1;
  /**
   * 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 DeploymentProviderUnion1 =
  | DeploymentProviderAwsAlb1
  | DeploymentProviderAzureApplicationGatewayForContainers1
  | DeploymentProviderGkeGateway1
  | any;

/**
 * Shared Ingress route profile values.
 */
export type DeploymentRouteIngress1 = {
  /**
   * 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?:
    | DeploymentProviderAwsAlb1
    | DeploymentProviderAzureApplicationGatewayForContainers1
    | DeploymentProviderGkeGateway1
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type DeploymentRouteUnion1 =
  | DeploymentRouteIngress1
  | DeploymentRouteGateway1;

export type DeploymentExposureGenerated = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | DeploymentCertificateTLSSecretRef1
    | DeploymentCertificateManagedAcmImport1
    | DeploymentCertificateAwsAcmArn1
    | DeploymentCertificateManagedTLSSecret1
    | DeploymentCertificateNone1;
  mode: DeploymentModeGenerated;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: DeploymentRouteIngress1 | DeploymentRouteGateway1;
};

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

export type DeploymentExposureDisabled = {
  mode: DeploymentModeDisabled;
};

export type DeploymentExposureUnion =
  | DeploymentExposureCustom
  | DeploymentExposureGenerated
  | DeploymentExposureDisabled
  | 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 DeploymentKubernetes = {
  cluster?: DeploymentCluster | any | null | undefined;
  exposure?:
    | DeploymentExposureCustom
    | DeploymentExposureGenerated
    | DeploymentExposureDisabled
    | any
    | null
    | undefined;
};

export type DeploymentKubernetesUnion = DeploymentKubernetes | any;

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

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

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

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

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

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

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

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

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

export type DeploymentNetworkUseDefault = {
  type: DeploymentTypeUseDefault;
};

export type DeploymentNetworkUnion =
  | DeploymentNetworkByoVpcAws
  | DeploymentNetworkByoVpcGcp
  | DeploymentNetworkByoVnetAzure
  | DeploymentNetworkUseDefault
  | DeploymentNetworkCreate
  | any;

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

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

/**
 * User-provided configuration (network, deployment model, approvals)
 */
export type DeploymentStackSettings = {
  compute?: DeploymentCompute | any | null | undefined;
  /**
   * Deployment model: how updates are delivered to the remote environment.
   */
  deploymentModel?: DeploymentDeploymentModel | undefined;
  domains?: DeploymentDomains | 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?: DeploymentExternalBindings | null | undefined;
  /**
   * How heartbeat health checks are handled.
   */
  heartbeats?: DeploymentHeartbeats | undefined;
  kubernetes?: DeploymentKubernetes | any | null | undefined;
  network?:
    | DeploymentNetworkByoVpcAws
    | DeploymentNetworkByoVpcGcp
    | DeploymentNetworkByoVnetAzure
    | DeploymentNetworkUseDefault
    | DeploymentNetworkCreate
    | 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?: DeploymentTelemetry | undefined;
  /**
   * How updates are delivered to the deployment.
   */
  updates?: DeploymentUpdates | undefined;
};

/**
 * Represents the target cloud platform.
 */
export const DeploymentStackStatePlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Local: "local",
  Test: "test",
} as const;
/**
 * Represents the target cloud platform.
 */
export type DeploymentStackStatePlatform = ClosedEnum<
  typeof DeploymentStackStatePlatform
>;

/**
 * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
 */
export type DeploymentStackStateConfig = {
  /**
   * The unique identifier for this specific resource instance. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
   */
  id: string;
  /**
   * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
   */
  type: string;
  additionalProperties?: { [k: string]: any | null } | undefined;
};

/**
 * Represents the target cloud platform.
 */
export const DeploymentControllerPlatformEnum = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Local: "local",
  Test: "test",
} as const;
/**
 * Represents the target cloud platform.
 */
export type DeploymentControllerPlatformEnum = ClosedEnum<
  typeof DeploymentControllerPlatformEnum
>;

export type DeploymentControllerPlatformUnion =
  | DeploymentControllerPlatformEnum
  | any;

/**
 * Reference to a resource by its stable id and resource type.
 */
export type DeploymentStackStateDependency = {
  id: string;
  /**
   * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
   */
  type: string;
};

/**
 * Canonical error container that provides a structured way to represent errors
 *
 * @remarks
 * with rich metadata including error codes, human-readable messages, context,
 * and chaining capabilities for error propagation.
 *
 * This struct is designed to be both machine-readable and user-friendly,
 * supporting serialization for API responses and detailed error reporting
 * in distributed systems.
 */
export type DeploymentErrorStackState = {
  /**
   * A unique identifier for the type of error.
   *
   * @remarks
   *
   * This should be a short, machine-readable string that can be used
   * by clients to programmatically handle different error types.
   * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
   */
  code: string;
  /**
   * Additional diagnostic information about the error context.
   *
   * @remarks
   *
   * This optional field can contain structured data providing more details
   * about the error, such as validation errors, request parameters that
   * caused the issue, or other relevant context information.
   */
  context?: any | null | undefined;
  /**
   * Optional human-facing remediation hint.
   */
  hint?: string | null | undefined;
  /**
   * HTTP status code for this error.
   *
   * @remarks
   *
   * Used when converting the error to an HTTP response. If None, falls back to
   * the error type's default status code or 500.
   */
  httpStatusCode?: number | null | undefined;
  /**
   * Indicates if this is an internal error that should not be exposed to users.
   *
   * @remarks
   *
   * When `true`, this error contains sensitive information or implementation
   * details that should not be shown to end-users. Such errors should be
   * logged for debugging but replaced with generic error messages in responses.
   */
  internal: boolean;
  /**
   * Human-readable error message.
   *
   * @remarks
   *
   * This message should be clear and actionable for developers or end-users,
   * providing context about what went wrong and potentially how to fix it.
   */
  message: string;
  /**
   * Indicates whether the operation that caused the error should be retried.
   *
   * @remarks
   *
   * When `true`, the error is transient and the operation might succeed
   * if attempted again. When `false`, retrying the same operation is
   * unlikely to succeed without changes.
   */
  retryable: boolean;
  /**
   * The underlying error that caused this error, creating an error chain.
   *
   * @remarks
   *
   * This allows for proper error propagation and debugging by maintaining
   * the full context of how an error occurred through multiple layers
   * of an application.
   */
  source?: any | null | undefined;
};

export type DeploymentErrorUnion = DeploymentErrorStackState | any;

/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export const DeploymentLifecycleStackStateEnum = {
  Frozen: "frozen",
  Live: "live",
} as const;
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export type DeploymentLifecycleStackStateEnum = ClosedEnum<
  typeof DeploymentLifecycleStackStateEnum
>;

export type DeploymentLifecycleUnion = DeploymentLifecycleStackStateEnum | any;

/**
 * Resource outputs that can hold output data for any resource type in the Alien system. All resource outputs share a common 'type' field with additional type-specific output properties.
 */
export type DeploymentOutputs = {
  /**
   * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
   */
  type: string;
  additionalProperties?: { [k: string]: any | null } | undefined;
};

export type DeploymentOutputsUnion = DeploymentOutputs | any;

/**
 * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
 */
export type DeploymentPreviousConfig = {
  /**
   * The unique identifier for this specific resource instance. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
   */
  id: string;
  /**
   * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
   */
  type: string;
  additionalProperties?: { [k: string]: any | null } | undefined;
};

export type DeploymentPreviousConfigUnion = DeploymentPreviousConfig | any;

/**
 * Represents the high-level status of a resource during its lifecycle.
 */
export const DeploymentStackStateStatus = {
  Pending: "pending",
  Provisioning: "provisioning",
  ProvisionFailed: "provision-failed",
  Running: "running",
  Updating: "updating",
  UpdateFailed: "update-failed",
  Deleting: "deleting",
  DeleteFailed: "delete-failed",
  TeardownRequired: "teardown-required",
  Deleted: "deleted",
  RefreshFailed: "refresh-failed",
} as const;
/**
 * Represents the high-level status of a resource during its lifecycle.
 */
export type DeploymentStackStateStatus = ClosedEnum<
  typeof DeploymentStackStateStatus
>;

/**
 * Represents the state of a single resource within the stack for a specific platform.
 */
export type DeploymentStackStateResources = {
  /**
   * The platform-specific resource controller that manages this resource's lifecycle.
   *
   * @remarks
   * This is None when the resource status is Pending.
   * Stored as JSON to make the struct serializable and movable to alien-core.
   */
  internal?: any | null | undefined;
  /**
   * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
   */
  config: DeploymentStackStateConfig;
  controllerPlatform?:
    | DeploymentControllerPlatformEnum
    | any
    | null
    | undefined;
  /**
   * Complete list of dependencies for this resource, including infrastructure dependencies.
   *
   * @remarks
   * This preserves the full dependency information from the stack definition.
   */
  dependencies?: Array<DeploymentStackStateDependency> | undefined;
  error?: DeploymentErrorStackState | any | null | undefined;
  /**
   * Stores the controller state that failed, used for manual retry operations.
   *
   * @remarks
   * This allows resuming from the exact point where the failure occurred.
   * Stored as JSON to make the struct serializable and movable to alien-core.
   */
  lastFailedState?: any | null | undefined;
  lifecycle?: DeploymentLifecycleStackStateEnum | any | null | undefined;
  outputs?: DeploymentOutputs | any | null | undefined;
  previousConfig?: DeploymentPreviousConfig | any | null | undefined;
  /**
   * Binding parameters for remote access.
   *
   * @remarks
   * Only populated when the resource has `remote_access: true` in its ResourceEntry.
   * This is the JSON serialization of the binding configuration (e.g., StorageBinding, VaultBinding).
   * Populated by controllers during provisioning using get_binding_params().
   */
  remoteBindingParams?: any | null | undefined;
  /**
   * Tracks consecutive retry attempts for the current state transition.
   */
  retryAttempt?: number | undefined;
  /**
   * Represents the high-level status of a resource during its lifecycle.
   */
  status: DeploymentStackStateStatus;
  /**
   * The high-level type of the resource (e.g., Worker::RESOURCE_TYPE, Storage::RESOURCE_TYPE).
   */
  type: string;
};

/**
 * State of infrastructure components managed by this deployment
 */
export type DeploymentStackState = {
  /**
   * Represents the target cloud platform.
   */
  platform: DeploymentStackStatePlatform;
  /**
   * A prefix used for resource naming to ensure uniqueness across deployments.
   */
  resourcePrefix: string;
  /**
   * The state of individual resources, keyed by resource ID.
   */
  resources: { [k: string]: DeploymentStackStateResources };
};

/**
 * Actor that owns structural work during the initial setup phase.
 */
export const DeploymentInitialSetupAuthority = {
  ImportedHandoff: "importedHandoff",
  DirectSetup: "directSetup",
} as const;
/**
 * Actor that owns structural work during the initial setup phase.
 */
export type DeploymentInitialSetupAuthority = ClosedEnum<
  typeof DeploymentInitialSetupAuthority
>;

export const DeploymentPendingPreparedStackTypeStringList = {
  StringList: "stringList",
} as const;
export type DeploymentPendingPreparedStackTypeStringList = ClosedEnum<
  typeof DeploymentPendingPreparedStackTypeStringList
>;

export type DeploymentPendingPreparedStackDefaultStringList = {
  type: DeploymentPendingPreparedStackTypeStringList;
  /**
   * String list default.
   */
  value: Array<string>;
};

export const DeploymentPendingPreparedStackTypeBoolean = {
  Boolean: "boolean",
} as const;
export type DeploymentPendingPreparedStackTypeBoolean = ClosedEnum<
  typeof DeploymentPendingPreparedStackTypeBoolean
>;

export type DeploymentPendingPreparedStackDefaultBoolean = {
  type: DeploymentPendingPreparedStackTypeBoolean;
  /**
   * Boolean default.
   */
  value: boolean;
};

export const DeploymentPendingPreparedStackTypeNumber = {
  Number: "number",
} as const;
export type DeploymentPendingPreparedStackTypeNumber = ClosedEnum<
  typeof DeploymentPendingPreparedStackTypeNumber
>;

export type DeploymentPendingPreparedStackDefaultNumber = {
  type: DeploymentPendingPreparedStackTypeNumber;
  /**
   * Number default.
   */
  value: string;
};

export const DeploymentPendingPreparedStackTypeString = {
  String: "string",
} as const;
export type DeploymentPendingPreparedStackTypeString = ClosedEnum<
  typeof DeploymentPendingPreparedStackTypeString
>;

export type DeploymentPendingPreparedStackDefaultString = {
  type: DeploymentPendingPreparedStackTypeString;
  /**
   * String default.
   */
  value: string;
};

export type DeploymentPendingPreparedStackDefaultUnion =
  | DeploymentPendingPreparedStackDefaultString
  | DeploymentPendingPreparedStackDefaultNumber
  | DeploymentPendingPreparedStackDefaultBoolean
  | DeploymentPendingPreparedStackDefaultStringList
  | any;

/**
 * Environment variable handling for a stack input mapping.
 */
export const DeploymentPendingPreparedStackTypeEnvEnum = {
  Plain: "plain",
  Secret: "secret",
} as const;
/**
 * Environment variable handling for a stack input mapping.
 */
export type DeploymentPendingPreparedStackTypeEnvEnum = ClosedEnum<
  typeof DeploymentPendingPreparedStackTypeEnvEnum
>;

export type DeploymentPendingPreparedStackTypeUnion =
  | DeploymentPendingPreparedStackTypeEnvEnum
  | any;

/**
 * How a resolved stack input is injected into runtime environment variables.
 */
export type DeploymentPendingPreparedStackEnv = {
  /**
   * Environment variable name.
   */
  name: string;
  /**
   * Target resource IDs or patterns. None means every env-capable resource.
   */
  targetResources?: Array<string> | null | undefined;
  type?: DeploymentPendingPreparedStackTypeEnvEnum | any | null | undefined;
};

/**
 * Primitive stack input kind.
 */
export const DeploymentPendingPreparedStackKind = {
  String: "string",
  Secret: "secret",
  Number: "number",
  Integer: "integer",
  Boolean: "boolean",
  Enum: "enum",
  StringList: "stringList",
} as const;
/**
 * Primitive stack input kind.
 */
export type DeploymentPendingPreparedStackKind = ClosedEnum<
  typeof DeploymentPendingPreparedStackKind
>;

/**
 * Represents the target cloud platform.
 */
export const DeploymentPendingPreparedStackPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Local: "local",
  Test: "test",
} as const;
/**
 * Represents the target cloud platform.
 */
export type DeploymentPendingPreparedStackPlatform = ClosedEnum<
  typeof DeploymentPendingPreparedStackPlatform
>;

/**
 * Who can provide a stack input value.
 */
export const DeploymentPendingPreparedStackProvidedBy = {
  Developer: "developer",
  Deployer: "deployer",
} as const;
/**
 * Who can provide a stack input value.
 */
export type DeploymentPendingPreparedStackProvidedBy = ClosedEnum<
  typeof DeploymentPendingPreparedStackProvidedBy
>;

/**
 * Portable stack input validation constraints.
 */
export type DeploymentPendingPreparedStackValidation = {
  /**
   * Semantic format hint such as url.
   */
  format?: string | null | undefined;
  /**
   * Maximum number.
   */
  max?: string | null | undefined;
  /**
   * Maximum string-list items.
   */
  maxItems?: number | null | undefined;
  /**
   * Maximum string length.
   */
  maxLength?: number | null | undefined;
  /**
   * Minimum number.
   */
  min?: string | null | undefined;
  /**
   * Minimum string-list items.
   */
  minItems?: number | null | undefined;
  /**
   * Minimum string length.
   */
  minLength?: number | null | undefined;
  /**
   * Portable whole-value regex pattern.
   */
  pattern?: string | null | undefined;
  /**
   * Allowed string enum values.
   */
  values?: Array<string> | null | undefined;
};

export type DeploymentPendingPreparedStackValidationUnion =
  | DeploymentPendingPreparedStackValidation
  | any;

/**
 * Stack input definition serialized into a release stack.
 */
export type DeploymentPendingPreparedStackInput = {
  default?:
    | DeploymentPendingPreparedStackDefaultString
    | DeploymentPendingPreparedStackDefaultNumber
    | DeploymentPendingPreparedStackDefaultBoolean
    | DeploymentPendingPreparedStackDefaultStringList
    | any
    | null
    | undefined;
  /**
   * Human-facing helper text.
   */
  description: string;
  /**
   * Runtime env-var mappings for v1 input resolution.
   */
  env?: Array<DeploymentPendingPreparedStackEnv> | undefined;
  /**
   * Stable input ID used by CLI/API calls.
   */
  id: string;
  /**
   * Primitive stack input kind.
   */
  kind: DeploymentPendingPreparedStackKind;
  /**
   * Human-facing field label.
   */
  label: string;
  /**
   * Example placeholder shown in UI.
   */
  placeholder?: string | null | undefined;
  /**
   * Platforms where this input applies.
   */
  platforms?: Array<DeploymentPendingPreparedStackPlatform> | null | undefined;
  /**
   * Who can provide this value.
   */
  providedBy: Array<DeploymentPendingPreparedStackProvidedBy>;
  /**
   * Whether a resolved value is required before deployment can proceed.
   */
  required: boolean;
  validation?:
    | DeploymentPendingPreparedStackValidation
    | any
    | null
    | undefined;
};

export const DeploymentPendingPreparedStackManagementEnum = {
  Auto: "auto",
} as const;
export type DeploymentPendingPreparedStackManagementEnum = ClosedEnum<
  typeof DeploymentPendingPreparedStackManagementEnum
>;

/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideAwResource = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideAwStack = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackOverrideAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: DeploymentPendingPreparedStackOverrideAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: DeploymentPendingPreparedStackOverrideAwStack | undefined;
};

/**
 * IAM effect. Defaults to Allow.
 */
export const DeploymentPendingPreparedStackOverrideEffect = {
  Allow: "Allow",
  Deny: "Deny",
} as const;
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPendingPreparedStackOverrideEffect = ClosedEnum<
  typeof DeploymentPendingPreparedStackOverrideEffect
>;

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackOverrideAwGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackOverrideAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPendingPreparedStackOverrideAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: DeploymentPendingPreparedStackOverrideEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPendingPreparedStackOverrideAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideAzureResource = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideAzureStack = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackOverrideAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?: DeploymentPendingPreparedStackOverrideAzureResource | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: DeploymentPendingPreparedStackOverrideAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackOverrideAzureGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackOverrideAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPendingPreparedStackOverrideAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPendingPreparedStackOverrideAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackOverrideConditionResource = {
  expression: string;
  title: string;
};

export type DeploymentPendingPreparedStackOverrideResourceConditionUnion =
  | DeploymentPendingPreparedStackOverrideConditionResource
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideGcpResource = {
  condition?:
    | DeploymentPendingPreparedStackOverrideConditionResource
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackOverrideConditionStack = {
  expression: string;
  title: string;
};

export type DeploymentPendingPreparedStackOverrideStackConditionUnion =
  | DeploymentPendingPreparedStackOverrideConditionStack
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackOverrideGcpStack = {
  condition?:
    | DeploymentPendingPreparedStackOverrideConditionStack
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackOverrideGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?: DeploymentPendingPreparedStackOverrideGcpResource | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: DeploymentPendingPreparedStackOverrideGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackOverrideGcpGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackOverrideGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPendingPreparedStackOverrideGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPendingPreparedStackOverrideGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type DeploymentPendingPreparedStackOverridePlatforms = {
  /**
   * AWS permission configurations
   */
  aws?: Array<DeploymentPendingPreparedStackOverrideAw> | null | undefined;
  /**
   * Azure permission configurations
   */
  azure?: Array<DeploymentPendingPreparedStackOverrideAzure> | null | undefined;
  /**
   * GCP permission configurations
   */
  gcp?: Array<DeploymentPendingPreparedStackOverrideGcp> | null | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPendingPreparedStackOverride = {
  /**
   * Human-readable description of what this permission set allows
   */
  description: string;
  /**
   * Unique identifier for the permission set (e.g., "storage/data-read")
   */
  id: string;
  /**
   * Platform-specific permission configurations
   */
  platforms: DeploymentPendingPreparedStackOverridePlatforms;
};

/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPendingPreparedStackOverrideUnion =
  | DeploymentPendingPreparedStackOverride
  | string;

export type DeploymentPendingPreparedStackManagement2 = {
  /**
   * Permission profile that maps resources to permission sets
   *
   * @remarks
   * Key can be "*" for all resources or resource name for specific resource
   */
  override: {
    [k: string]: Array<DeploymentPendingPreparedStackOverride | string>;
  };
};

/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendAwResource = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendAwStack = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackExtendAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: DeploymentPendingPreparedStackExtendAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: DeploymentPendingPreparedStackExtendAwStack | undefined;
};

/**
 * IAM effect. Defaults to Allow.
 */
export const DeploymentPendingPreparedStackExtendEffect = {
  Allow: "Allow",
  Deny: "Deny",
} as const;
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPendingPreparedStackExtendEffect = ClosedEnum<
  typeof DeploymentPendingPreparedStackExtendEffect
>;

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackExtendAwGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackExtendAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPendingPreparedStackExtendAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: DeploymentPendingPreparedStackExtendEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPendingPreparedStackExtendAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendAzureResource = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendAzureStack = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackExtendAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?: DeploymentPendingPreparedStackExtendAzureResource | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: DeploymentPendingPreparedStackExtendAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackExtendAzureGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackExtendAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPendingPreparedStackExtendAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPendingPreparedStackExtendAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackExtendConditionResource = {
  expression: string;
  title: string;
};

export type DeploymentPendingPreparedStackExtendResourceConditionUnion =
  | DeploymentPendingPreparedStackExtendConditionResource
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendGcpResource = {
  condition?:
    | DeploymentPendingPreparedStackExtendConditionResource
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackExtendConditionStack = {
  expression: string;
  title: string;
};

export type DeploymentPendingPreparedStackExtendStackConditionUnion =
  | DeploymentPendingPreparedStackExtendConditionStack
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackExtendGcpStack = {
  condition?:
    | DeploymentPendingPreparedStackExtendConditionStack
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackExtendGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?: DeploymentPendingPreparedStackExtendGcpResource | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: DeploymentPendingPreparedStackExtendGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackExtendGcpGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackExtendGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPendingPreparedStackExtendGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPendingPreparedStackExtendGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type DeploymentPendingPreparedStackExtendPlatforms = {
  /**
   * AWS permission configurations
   */
  aws?: Array<DeploymentPendingPreparedStackExtendAw> | null | undefined;
  /**
   * Azure permission configurations
   */
  azure?: Array<DeploymentPendingPreparedStackExtendAzure> | null | undefined;
  /**
   * GCP permission configurations
   */
  gcp?: Array<DeploymentPendingPreparedStackExtendGcp> | null | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPendingPreparedStackExtend = {
  /**
   * Human-readable description of what this permission set allows
   */
  description: string;
  /**
   * Unique identifier for the permission set (e.g., "storage/data-read")
   */
  id: string;
  /**
   * Platform-specific permission configurations
   */
  platforms: DeploymentPendingPreparedStackExtendPlatforms;
};

/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPendingPreparedStackExtendUnion =
  | DeploymentPendingPreparedStackExtend
  | string;

export type DeploymentPendingPreparedStackManagement1 = {
  /**
   * Permission profile that maps resources to permission sets
   *
   * @remarks
   * Key can be "*" for all resources or resource name for specific resource
   */
  extend: { [k: string]: Array<DeploymentPendingPreparedStackExtend | string> };
};

/**
 * Management permissions configuration for stack management access
 */
export type DeploymentPendingPreparedStackManagementUnion =
  | DeploymentPendingPreparedStackManagement1
  | DeploymentPendingPreparedStackManagement2
  | DeploymentPendingPreparedStackManagementEnum;

/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileAwResource = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * AWS-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileAwStack = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackProfileAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: DeploymentPendingPreparedStackProfileAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: DeploymentPendingPreparedStackProfileAwStack | undefined;
};

/**
 * IAM effect. Defaults to Allow.
 */
export const DeploymentPendingPreparedStackProfileEffect = {
  Allow: "Allow",
  Deny: "Deny",
} as const;
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPendingPreparedStackProfileEffect = ClosedEnum<
  typeof DeploymentPendingPreparedStackProfileEffect
>;

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackProfileAwGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackProfileAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPendingPreparedStackProfileAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: DeploymentPendingPreparedStackProfileEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPendingPreparedStackProfileAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileAzureResource = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileAzureStack = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackProfileAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?: DeploymentPendingPreparedStackProfileAzureResource | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: DeploymentPendingPreparedStackProfileAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackProfileAzureGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackProfileAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPendingPreparedStackProfileAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPendingPreparedStackProfileAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackProfileConditionResource = {
  expression: string;
  title: string;
};

export type DeploymentPendingPreparedStackProfileResourceConditionUnion =
  | DeploymentPendingPreparedStackProfileConditionResource
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileGcpResource = {
  condition?:
    | DeploymentPendingPreparedStackProfileConditionResource
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * GCP IAM condition
 */
export type DeploymentPendingPreparedStackProfileConditionStack = {
  expression: string;
  title: string;
};

export type DeploymentPendingPreparedStackProfileStackConditionUnion =
  | DeploymentPendingPreparedStackProfileConditionStack
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPendingPreparedStackProfileGcpStack = {
  condition?:
    | DeploymentPendingPreparedStackProfileConditionStack
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPendingPreparedStackProfileGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?: DeploymentPendingPreparedStackProfileGcpResource | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: DeploymentPendingPreparedStackProfileGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPendingPreparedStackProfileGcpGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPendingPreparedStackProfileGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPendingPreparedStackProfileGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPendingPreparedStackProfileGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type DeploymentPendingPreparedStackProfilePlatforms = {
  /**
   * AWS permission configurations
   */
  aws?: Array<DeploymentPendingPreparedStackProfileAw> | null | undefined;
  /**
   * Azure permission configurations
   */
  azure?: Array<DeploymentPendingPreparedStackProfileAzure> | null | undefined;
  /**
   * GCP permission configurations
   */
  gcp?: Array<DeploymentPendingPreparedStackProfileGcp> | null | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPendingPreparedStackProfile = {
  /**
   * Human-readable description of what this permission set allows
   */
  description: string;
  /**
   * Unique identifier for the permission set (e.g., "storage/data-read")
   */
  id: string;
  /**
   * Platform-specific permission configurations
   */
  platforms: DeploymentPendingPreparedStackProfilePlatforms;
};

/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPendingPreparedStackProfileUnion =
  | DeploymentPendingPreparedStackProfile
  | string;

/**
 * Combined permissions configuration that contains both profiles and management
 */
export type DeploymentPendingPreparedStackPermissions = {
  /**
   * Management permissions configuration for stack management access
   */
  management?:
    | DeploymentPendingPreparedStackManagement1
    | DeploymentPendingPreparedStackManagement2
    | DeploymentPendingPreparedStackManagementEnum
    | undefined;
  /**
   * Permission profiles that define access control for compute services
   *
   * @remarks
   * Key is the profile name, value is the permission configuration
   */
  profiles: {
    [k: string]: {
      [k: string]: Array<DeploymentPendingPreparedStackProfile | string>;
    };
  };
};

/**
 * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
 */
export type DeploymentPendingPreparedStackConfig = {
  /**
   * The unique identifier for this specific resource instance. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
   */
  id: string;
  /**
   * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
   */
  type: string;
  additionalProperties?: { [k: string]: any | null } | undefined;
};

/**
 * Reference to a resource by its stable id and resource type.
 */
export type DeploymentPendingPreparedStackDependency = {
  id: string;
  /**
   * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
   */
  type: string;
};

/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export const DeploymentPendingPreparedStackLifecycle = {
  Frozen: "frozen",
  Live: "live",
} as const;
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export type DeploymentPendingPreparedStackLifecycle = ClosedEnum<
  typeof DeploymentPendingPreparedStackLifecycle
>;

export type DeploymentPendingPreparedStackResources = {
  /**
   * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
   */
  config: DeploymentPendingPreparedStackConfig;
  /**
   * Additional dependencies for this resource beyond those defined in the resource itself.
   *
   * @remarks
   * The total dependencies are: resource.get_dependencies() + this list
   */
  dependencies: Array<DeploymentPendingPreparedStackDependency>;
  /**
   * Id of the boolean stack input that decides whether this resource is
   *
   * @remarks
   * created at all. `None` means always create it.
   *
   * Set by `.enabled(input)` in the SDK. Setup emitters render the resource
   * conditionally on the matching template variable, so a deployer who says no
   * never gets the resource, its outputs, or anything derived from it.
   */
  enabledWhen?: string | null | undefined;
  /**
   * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
   */
  lifecycle: DeploymentPendingPreparedStackLifecycle;
  /**
   * Enable remote bindings for this resource (BYOB use case).
   *
   * @remarks
   * When true, binding params are synced to StackState's `remote_binding_params`.
   * Default: false (prevents sensitive data in synced state).
   */
  remoteAccess?: boolean | undefined;
};

/**
 * Represents the target cloud platform.
 */
export const DeploymentPendingPreparedStackSupportedPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Local: "local",
  Test: "test",
} as const;
/**
 * Represents the target cloud platform.
 */
export type DeploymentPendingPreparedStackSupportedPlatform = ClosedEnum<
  typeof DeploymentPendingPreparedStackSupportedPlatform
>;

/**
 * A bag of resources, unaware of any cloud.
 */
export type DeploymentPendingPreparedStack = {
  /**
   * Unique identifier for the stack
   */
  id: string;
  /**
   * Input definitions required before setup or deployment can proceed.
   */
  inputs?: Array<DeploymentPendingPreparedStackInput> | undefined;
  /**
   * Combined permissions configuration that contains both profiles and management
   */
  permissions?: DeploymentPendingPreparedStackPermissions | undefined;
  /**
   * Map of resource IDs to their configurations and lifecycle settings
   */
  resources: { [k: string]: DeploymentPendingPreparedStackResources };
  /**
   * Which platforms this stack supports. When None, all platforms are supported.
   */
  supportedPlatforms?:
    | Array<DeploymentPendingPreparedStackSupportedPlatform>
    | null
    | undefined;
};

export type DeploymentPendingPreparedStackUnion =
  | DeploymentPendingPreparedStack
  | any;

export const DeploymentPreparedStackTypeStringList = {
  StringList: "stringList",
} as const;
export type DeploymentPreparedStackTypeStringList = ClosedEnum<
  typeof DeploymentPreparedStackTypeStringList
>;

export type DeploymentPreparedStackDefaultStringList = {
  type: DeploymentPreparedStackTypeStringList;
  /**
   * String list default.
   */
  value: Array<string>;
};

export const DeploymentPreparedStackTypeBoolean = {
  Boolean: "boolean",
} as const;
export type DeploymentPreparedStackTypeBoolean = ClosedEnum<
  typeof DeploymentPreparedStackTypeBoolean
>;

export type DeploymentPreparedStackDefaultBoolean = {
  type: DeploymentPreparedStackTypeBoolean;
  /**
   * Boolean default.
   */
  value: boolean;
};

export const DeploymentPreparedStackTypeNumber = {
  Number: "number",
} as const;
export type DeploymentPreparedStackTypeNumber = ClosedEnum<
  typeof DeploymentPreparedStackTypeNumber
>;

export type DeploymentPreparedStackDefaultNumber = {
  type: DeploymentPreparedStackTypeNumber;
  /**
   * Number default.
   */
  value: string;
};

export const DeploymentPreparedStackTypeString = {
  String: "string",
} as const;
export type DeploymentPreparedStackTypeString = ClosedEnum<
  typeof DeploymentPreparedStackTypeString
>;

export type DeploymentPreparedStackDefaultString = {
  type: DeploymentPreparedStackTypeString;
  /**
   * String default.
   */
  value: string;
};

export type DeploymentPreparedStackDefaultUnion =
  | DeploymentPreparedStackDefaultString
  | DeploymentPreparedStackDefaultNumber
  | DeploymentPreparedStackDefaultBoolean
  | DeploymentPreparedStackDefaultStringList
  | any;

/**
 * Environment variable handling for a stack input mapping.
 */
export const DeploymentPreparedStackTypeEnvEnum = {
  Plain: "plain",
  Secret: "secret",
} as const;
/**
 * Environment variable handling for a stack input mapping.
 */
export type DeploymentPreparedStackTypeEnvEnum = ClosedEnum<
  typeof DeploymentPreparedStackTypeEnvEnum
>;

export type DeploymentPreparedStackTypeUnion =
  | DeploymentPreparedStackTypeEnvEnum
  | any;

/**
 * How a resolved stack input is injected into runtime environment variables.
 */
export type DeploymentPreparedStackEnv = {
  /**
   * Environment variable name.
   */
  name: string;
  /**
   * Target resource IDs or patterns. None means every env-capable resource.
   */
  targetResources?: Array<string> | null | undefined;
  type?: DeploymentPreparedStackTypeEnvEnum | any | null | undefined;
};

/**
 * Primitive stack input kind.
 */
export const DeploymentPreparedStackKind = {
  String: "string",
  Secret: "secret",
  Number: "number",
  Integer: "integer",
  Boolean: "boolean",
  Enum: "enum",
  StringList: "stringList",
} as const;
/**
 * Primitive stack input kind.
 */
export type DeploymentPreparedStackKind = ClosedEnum<
  typeof DeploymentPreparedStackKind
>;

/**
 * Represents the target cloud platform.
 */
export const DeploymentPreparedStackPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Local: "local",
  Test: "test",
} as const;
/**
 * Represents the target cloud platform.
 */
export type DeploymentPreparedStackPlatform = ClosedEnum<
  typeof DeploymentPreparedStackPlatform
>;

/**
 * Who can provide a stack input value.
 */
export const DeploymentPreparedStackProvidedBy = {
  Developer: "developer",
  Deployer: "deployer",
} as const;
/**
 * Who can provide a stack input value.
 */
export type DeploymentPreparedStackProvidedBy = ClosedEnum<
  typeof DeploymentPreparedStackProvidedBy
>;

/**
 * Portable stack input validation constraints.
 */
export type DeploymentPreparedStackValidation = {
  /**
   * Semantic format hint such as url.
   */
  format?: string | null | undefined;
  /**
   * Maximum number.
   */
  max?: string | null | undefined;
  /**
   * Maximum string-list items.
   */
  maxItems?: number | null | undefined;
  /**
   * Maximum string length.
   */
  maxLength?: number | null | undefined;
  /**
   * Minimum number.
   */
  min?: string | null | undefined;
  /**
   * Minimum string-list items.
   */
  minItems?: number | null | undefined;
  /**
   * Minimum string length.
   */
  minLength?: number | null | undefined;
  /**
   * Portable whole-value regex pattern.
   */
  pattern?: string | null | undefined;
  /**
   * Allowed string enum values.
   */
  values?: Array<string> | null | undefined;
};

export type DeploymentPreparedStackValidationUnion =
  | DeploymentPreparedStackValidation
  | any;

/**
 * Stack input definition serialized into a release stack.
 */
export type DeploymentPreparedStackInput = {
  default?:
    | DeploymentPreparedStackDefaultString
    | DeploymentPreparedStackDefaultNumber
    | DeploymentPreparedStackDefaultBoolean
    | DeploymentPreparedStackDefaultStringList
    | any
    | null
    | undefined;
  /**
   * Human-facing helper text.
   */
  description: string;
  /**
   * Runtime env-var mappings for v1 input resolution.
   */
  env?: Array<DeploymentPreparedStackEnv> | undefined;
  /**
   * Stable input ID used by CLI/API calls.
   */
  id: string;
  /**
   * Primitive stack input kind.
   */
  kind: DeploymentPreparedStackKind;
  /**
   * Human-facing field label.
   */
  label: string;
  /**
   * Example placeholder shown in UI.
   */
  placeholder?: string | null | undefined;
  /**
   * Platforms where this input applies.
   */
  platforms?: Array<DeploymentPreparedStackPlatform> | null | undefined;
  /**
   * Who can provide this value.
   */
  providedBy: Array<DeploymentPreparedStackProvidedBy>;
  /**
   * Whether a resolved value is required before deployment can proceed.
   */
  required: boolean;
  validation?: DeploymentPreparedStackValidation | any | null | undefined;
};

export const DeploymentPreparedStackManagementEnum = {
  Auto: "auto",
} as const;
export type DeploymentPreparedStackManagementEnum = ClosedEnum<
  typeof DeploymentPreparedStackManagementEnum
>;

/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackOverrideAwResource = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackOverrideAwStack = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackOverrideAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: DeploymentPreparedStackOverrideAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: DeploymentPreparedStackOverrideAwStack | undefined;
};

/**
 * IAM effect. Defaults to Allow.
 */
export const DeploymentPreparedStackOverrideEffect = {
  Allow: "Allow",
  Deny: "Deny",
} as const;
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPreparedStackOverrideEffect = ClosedEnum<
  typeof DeploymentPreparedStackOverrideEffect
>;

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackOverrideAwGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPreparedStackOverrideAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPreparedStackOverrideAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: DeploymentPreparedStackOverrideEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPreparedStackOverrideAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackOverrideAzureResource = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackOverrideAzureStack = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackOverrideAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?: DeploymentPreparedStackOverrideAzureResource | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: DeploymentPreparedStackOverrideAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackOverrideAzureGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPreparedStackOverrideAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPreparedStackOverrideAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPreparedStackOverrideAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackOverrideConditionResource = {
  expression: string;
  title: string;
};

export type DeploymentPreparedStackOverrideResourceConditionUnion =
  | DeploymentPreparedStackOverrideConditionResource
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackOverrideGcpResource = {
  condition?:
    | DeploymentPreparedStackOverrideConditionResource
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackOverrideConditionStack = {
  expression: string;
  title: string;
};

export type DeploymentPreparedStackOverrideStackConditionUnion =
  | DeploymentPreparedStackOverrideConditionStack
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackOverrideGcpStack = {
  condition?:
    | DeploymentPreparedStackOverrideConditionStack
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackOverrideGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?: DeploymentPreparedStackOverrideGcpResource | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: DeploymentPreparedStackOverrideGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackOverrideGcpGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPreparedStackOverrideGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPreparedStackOverrideGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPreparedStackOverrideGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type DeploymentPreparedStackOverridePlatforms = {
  /**
   * AWS permission configurations
   */
  aws?: Array<DeploymentPreparedStackOverrideAw> | null | undefined;
  /**
   * Azure permission configurations
   */
  azure?: Array<DeploymentPreparedStackOverrideAzure> | null | undefined;
  /**
   * GCP permission configurations
   */
  gcp?: Array<DeploymentPreparedStackOverrideGcp> | null | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPreparedStackOverride = {
  /**
   * Human-readable description of what this permission set allows
   */
  description: string;
  /**
   * Unique identifier for the permission set (e.g., "storage/data-read")
   */
  id: string;
  /**
   * Platform-specific permission configurations
   */
  platforms: DeploymentPreparedStackOverridePlatforms;
};

/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPreparedStackOverrideUnion =
  | DeploymentPreparedStackOverride
  | string;

export type DeploymentPreparedStackManagement2 = {
  /**
   * Permission profile that maps resources to permission sets
   *
   * @remarks
   * Key can be "*" for all resources or resource name for specific resource
   */
  override: { [k: string]: Array<DeploymentPreparedStackOverride | string> };
};

/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackExtendAwResource = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackExtendAwStack = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackExtendAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: DeploymentPreparedStackExtendAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: DeploymentPreparedStackExtendAwStack | undefined;
};

/**
 * IAM effect. Defaults to Allow.
 */
export const DeploymentPreparedStackExtendEffect = {
  Allow: "Allow",
  Deny: "Deny",
} as const;
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPreparedStackExtendEffect = ClosedEnum<
  typeof DeploymentPreparedStackExtendEffect
>;

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackExtendAwGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPreparedStackExtendAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPreparedStackExtendAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: DeploymentPreparedStackExtendEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPreparedStackExtendAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackExtendAzureResource = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackExtendAzureStack = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackExtendAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?: DeploymentPreparedStackExtendAzureResource | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: DeploymentPreparedStackExtendAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackExtendAzureGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPreparedStackExtendAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPreparedStackExtendAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPreparedStackExtendAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackExtendConditionResource = {
  expression: string;
  title: string;
};

export type DeploymentPreparedStackExtendResourceConditionUnion =
  | DeploymentPreparedStackExtendConditionResource
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackExtendGcpResource = {
  condition?:
    | DeploymentPreparedStackExtendConditionResource
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackExtendConditionStack = {
  expression: string;
  title: string;
};

export type DeploymentPreparedStackExtendStackConditionUnion =
  | DeploymentPreparedStackExtendConditionStack
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackExtendGcpStack = {
  condition?:
    | DeploymentPreparedStackExtendConditionStack
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackExtendGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?: DeploymentPreparedStackExtendGcpResource | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: DeploymentPreparedStackExtendGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackExtendGcpGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPreparedStackExtendGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPreparedStackExtendGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPreparedStackExtendGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type DeploymentPreparedStackExtendPlatforms = {
  /**
   * AWS permission configurations
   */
  aws?: Array<DeploymentPreparedStackExtendAw> | null | undefined;
  /**
   * Azure permission configurations
   */
  azure?: Array<DeploymentPreparedStackExtendAzure> | null | undefined;
  /**
   * GCP permission configurations
   */
  gcp?: Array<DeploymentPreparedStackExtendGcp> | null | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPreparedStackExtend = {
  /**
   * Human-readable description of what this permission set allows
   */
  description: string;
  /**
   * Unique identifier for the permission set (e.g., "storage/data-read")
   */
  id: string;
  /**
   * Platform-specific permission configurations
   */
  platforms: DeploymentPreparedStackExtendPlatforms;
};

/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPreparedStackExtendUnion =
  | DeploymentPreparedStackExtend
  | string;

export type DeploymentPreparedStackManagement1 = {
  /**
   * Permission profile that maps resources to permission sets
   *
   * @remarks
   * Key can be "*" for all resources or resource name for specific resource
   */
  extend: { [k: string]: Array<DeploymentPreparedStackExtend | string> };
};

/**
 * Management permissions configuration for stack management access
 */
export type DeploymentPreparedStackManagementUnion =
  | DeploymentPreparedStackManagement1
  | DeploymentPreparedStackManagement2
  | DeploymentPreparedStackManagementEnum;

/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackProfileAwResource = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * AWS-specific binding specification
 */
export type DeploymentPreparedStackProfileAwStack = {
  /**
   * Optional condition for additional filtering (rare)
   */
  condition?: { [k: string]: { [k: string]: string } } | null | undefined;
  /**
   * Resource ARNs to bind to
   */
  resources: Array<string>;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackProfileAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: DeploymentPreparedStackProfileAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: DeploymentPreparedStackProfileAwStack | undefined;
};

/**
 * IAM effect. Defaults to Allow.
 */
export const DeploymentPreparedStackProfileEffect = {
  Allow: "Allow",
  Deny: "Deny",
} as const;
/**
 * IAM effect. Defaults to Allow.
 */
export type DeploymentPreparedStackProfileEffect = ClosedEnum<
  typeof DeploymentPreparedStackProfileEffect
>;

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackProfileAwGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * AWS-specific platform permission configuration
 */
export type DeploymentPreparedStackProfileAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPreparedStackProfileAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: DeploymentPreparedStackProfileEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPreparedStackProfileAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackProfileAzureResource = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Azure-specific binding specification
 */
export type DeploymentPreparedStackProfileAzureStack = {
  /**
   * Scope (subscription/resource group/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackProfileAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?: DeploymentPreparedStackProfileAzureResource | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: DeploymentPreparedStackProfileAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackProfileAzureGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * Azure-specific platform permission configuration
 */
export type DeploymentPreparedStackProfileAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPreparedStackProfileAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPreparedStackProfileAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackProfileConditionResource = {
  expression: string;
  title: string;
};

export type DeploymentPreparedStackProfileResourceConditionUnion =
  | DeploymentPreparedStackProfileConditionResource
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackProfileGcpResource = {
  condition?:
    | DeploymentPreparedStackProfileConditionResource
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * GCP IAM condition
 */
export type DeploymentPreparedStackProfileConditionStack = {
  expression: string;
  title: string;
};

export type DeploymentPreparedStackProfileStackConditionUnion =
  | DeploymentPreparedStackProfileConditionStack
  | any;

/**
 * GCP-specific binding specification
 */
export type DeploymentPreparedStackProfileGcpStack = {
  condition?:
    | DeploymentPreparedStackProfileConditionStack
    | any
    | null
    | undefined;
  /**
   * Scope (project/resource level)
   */
  scope: string;
};

/**
 * Generic binding configuration for permissions
 */
export type DeploymentPreparedStackProfileGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?: DeploymentPreparedStackProfileGcpResource | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: DeploymentPreparedStackProfileGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type DeploymentPreparedStackProfileGcpGrant = {
  /**
   * AWS IAM actions (only for AWS)
   */
  actions?: Array<string> | null | undefined;
  /**
   * Azure actions (only for Azure)
   */
  dataActions?: Array<string> | null | undefined;
  /**
   * GCP permissions that require an exact residual custom role.
   */
  permissions?: Array<string> | null | undefined;
  /**
   * Provider predefined roles to bind directly.
   */
  predefinedRoles?: Array<string> | null | undefined;
  /**
   * GCP residual custom permissions to pair with predefined roles.
   */
  residualPermissions?: Array<string> | null | undefined;
};

/**
 * GCP-specific platform permission configuration
 */
export type DeploymentPreparedStackProfileGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: DeploymentPreparedStackProfileGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: DeploymentPreparedStackProfileGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type DeploymentPreparedStackProfilePlatforms = {
  /**
   * AWS permission configurations
   */
  aws?: Array<DeploymentPreparedStackProfileAw> | null | undefined;
  /**
   * Azure permission configurations
   */
  azure?: Array<DeploymentPreparedStackProfileAzure> | null | undefined;
  /**
   * GCP permission configurations
   */
  gcp?: Array<DeploymentPreparedStackProfileGcp> | null | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type DeploymentPreparedStackProfile = {
  /**
   * Human-readable description of what this permission set allows
   */
  description: string;
  /**
   * Unique identifier for the permission set (e.g., "storage/data-read")
   */
  id: string;
  /**
   * Platform-specific permission configurations
   */
  platforms: DeploymentPreparedStackProfilePlatforms;
};

/**
 * Reference to a permission set - either by name or inline definition
 */
export type DeploymentPreparedStackProfileUnion =
  | DeploymentPreparedStackProfile
  | string;

/**
 * Combined permissions configuration that contains both profiles and management
 */
export type DeploymentPreparedStackPermissions = {
  /**
   * Management permissions configuration for stack management access
   */
  management?:
    | DeploymentPreparedStackManagement1
    | DeploymentPreparedStackManagement2
    | DeploymentPreparedStackManagementEnum
    | undefined;
  /**
   * Permission profiles that define access control for compute services
   *
   * @remarks
   * Key is the profile name, value is the permission configuration
   */
  profiles: {
    [k: string]: {
      [k: string]: Array<DeploymentPreparedStackProfile | string>;
    };
  };
};

/**
 * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
 */
export type DeploymentPreparedStackConfig = {
  /**
   * The unique identifier for this specific resource instance. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
   */
  id: string;
  /**
   * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
   */
  type: string;
  additionalProperties?: { [k: string]: any | null } | undefined;
};

/**
 * Reference to a resource by its stable id and resource type.
 */
export type DeploymentPreparedStackDependency = {
  id: string;
  /**
   * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
   */
  type: string;
};

/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export const DeploymentPreparedStackLifecycle = {
  Frozen: "frozen",
  Live: "live",
} as const;
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export type DeploymentPreparedStackLifecycle = ClosedEnum<
  typeof DeploymentPreparedStackLifecycle
>;

export type DeploymentPreparedStackResources = {
  /**
   * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
   */
  config: DeploymentPreparedStackConfig;
  /**
   * Additional dependencies for this resource beyond those defined in the resource itself.
   *
   * @remarks
   * The total dependencies are: resource.get_dependencies() + this list
   */
  dependencies: Array<DeploymentPreparedStackDependency>;
  /**
   * Id of the boolean stack input that decides whether this resource is
   *
   * @remarks
   * created at all. `None` means always create it.
   *
   * Set by `.enabled(input)` in the SDK. Setup emitters render the resource
   * conditionally on the matching template variable, so a deployer who says no
   * never gets the resource, its outputs, or anything derived from it.
   */
  enabledWhen?: string | null | undefined;
  /**
   * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
   */
  lifecycle: DeploymentPreparedStackLifecycle;
  /**
   * Enable remote bindings for this resource (BYOB use case).
   *
   * @remarks
   * When true, binding params are synced to StackState's `remote_binding_params`.
   * Default: false (prevents sensitive data in synced state).
   */
  remoteAccess?: boolean | undefined;
};

/**
 * Represents the target cloud platform.
 */
export const DeploymentPreparedStackSupportedPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Local: "local",
  Test: "test",
} as const;
/**
 * Represents the target cloud platform.
 */
export type DeploymentPreparedStackSupportedPlatform = ClosedEnum<
  typeof DeploymentPreparedStackSupportedPlatform
>;

/**
 * A bag of resources, unaware of any cloud.
 */
export type DeploymentPreparedStack = {
  /**
   * Unique identifier for the stack
   */
  id: string;
  /**
   * Input definitions required before setup or deployment can proceed.
   */
  inputs?: Array<DeploymentPreparedStackInput> | undefined;
  /**
   * Combined permissions configuration that contains both profiles and management
   */
  permissions?: DeploymentPreparedStackPermissions | undefined;
  /**
   * Map of resource IDs to their configurations and lifecycle settings
   */
  resources: { [k: string]: DeploymentPreparedStackResources };
  /**
   * Which platforms this stack supports. When None, all platforms are supported.
   */
  supportedPlatforms?:
    | Array<DeploymentPreparedStackSupportedPlatform>
    | null
    | undefined;
};

export type DeploymentPreparedStackUnion = DeploymentPreparedStack | any;

/**
 * One-shot authority for a setup re-import to replace setup-owned resources.
 */
export type DeploymentSetupUpdateAuthorization = {
  /**
   * Frozen resource projection from the last successful deployment.
   */
  baselineFrozenDigest: string;
  /**
   * Unique revision used by persistence layers for compare-and-swap updates.
   */
  nonce: string;
  /**
   * Release whose stack was prepared by setup.
   */
  releaseId: string;
  /**
   * Exact setup artifact revision that authored this authority.
   */
  setupFingerprint: string;
  /**
   * Setup fingerprint contract version.
   */
  setupFingerprintVersion: number;
  /**
   * Stable setup target recorded on the imported deployment.
   */
  setupTarget: string;
  /**
   * Frozen resource projection prepared by the setup re-import.
   */
  targetFrozenDigest: string;
};

export type DeploymentSetupUpdateAuthorizationUnion =
  | DeploymentSetupUpdateAuthorization
  | any;

/**
 * Runtime metadata for deployment state persistence
 */
export type DeploymentRuntimeMetadata = {
  /**
   * Last generated CLI package revision whose direct setup was applied.
   *
   * @remarks
   * This lets a newer generated CLI refresh setup-owned infrastructure once
   * before handing runtime changes back to the hosted manager.
   */
  directSetupRevision?: string | null | undefined;
  /**
   * Actor that owns structural work during the initial setup phase.
   */
  initialSetupAuthority?: DeploymentInitialSetupAuthority | undefined;
  /**
   * Hash of the environment variables snapshot that was last synced to the vault
   *
   * @remarks
   * Used to avoid redundant sync operations during incremental deployment
   */
  lastSyncedEnvVarsHash?: string | null | undefined;
  /**
   * Exact vault keys owned by the deployment secret synchronizer. This
   *
   * @remarks
   * inventory lets a later snapshot delete removed keys without listing or
   * touching unrelated values in the same vault.
   */
  lastSyncedSecretNames?: Array<string> | undefined;
  pendingPreparedStack?:
    | DeploymentPendingPreparedStack
    | any
    | null
    | undefined;
  /**
   * Canonical resolved answers for inputs that gate Frozen resources,
   *
   * @remarks
   * keyed by input id, recorded when the deployment is created or its
   * setup import registers.
   *
   * A frozen gate's answer is fixed for the deployment's lifetime: the
   * update path refuses input values that conflict with these, and a Live
   * resource sharing such an input resolves the persisted answer forever.
   */
  persistedGateAnswers?: { [k: string]: boolean } | undefined;
  preparedStack?: DeploymentPreparedStack | any | null | undefined;
  /**
   * Whether cross-account registry access has been successfully granted.
   *
   * @remarks
   * Set to true after the manager successfully sets the ECR/GAR repo policy
   * for this deployment's target account. Prevents redundant API calls on
   * every reconcile tick.
   */
  registryAccessGranted?: boolean | undefined;
  setupUpdateAuthorization?:
    | DeploymentSetupUpdateAuthorization
    | any
    | null
    | undefined;
};

/**
 * Setup source that imported this deployment
 */
export const DeploymentImportSource = {
  Cloudformation: "cloudformation",
  Terraform: "terraform",
  Helm: "helm",
} as const;
/**
 * Setup source that imported this deployment
 */
export type DeploymentImportSource = ClosedEnum<typeof DeploymentImportSource>;

/**
 * Setup method that created the deployment record and owns setup-time resources.
 */
export const DeploymentSetupMethod1 = {
  Cloudformation: "cloudformation",
  GoogleOauth: "google-oauth",
  Terraform: "terraform",
  Helm: "helm",
  Cli: "cli",
  Manual: "manual",
} as const;
/**
 * Setup method that created the deployment record and owns setup-time resources.
 */
export type DeploymentSetupMethod1 = ClosedEnum<typeof DeploymentSetupMethod1>;

/**
 * Latest error information if the deployment is in a failed state
 */
export type DeploymentError = {
  /**
   * A unique identifier for the type of error.
   *
   * @remarks
   *
   * This should be a short, machine-readable string that can be used
   * by clients to programmatically handle different error types.
   * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
   */
  code: string;
  /**
   * Additional diagnostic information about the error context.
   *
   * @remarks
   *
   * This optional field can contain structured data providing more details
   * about the error, such as validation errors, request parameters that
   * caused the issue, or other relevant context information.
   */
  context?: any | null | undefined;
  /**
   * Optional human-facing remediation hint.
   */
  hint?: string | null | undefined;
  /**
   * HTTP status code for this error.
   *
   * @remarks
   *
   * Used when converting the error to an HTTP response. If None, falls back to
   * the error type's default status code or 500.
   */
  httpStatusCode?: number | null | undefined;
  /**
   * Indicates if this is an internal error that should not be exposed to users.
   *
   * @remarks
   *
   * When `true`, this error contains sensitive information or implementation
   * details that should not be shown to end-users. Such errors should be
   * logged for debugging but replaced with generic error messages in responses.
   */
  internal: boolean;
  /**
   * Human-readable error message.
   *
   * @remarks
   *
   * This message should be clear and actionable for developers or end-users,
   * providing context about what went wrong and potentially how to fix it.
   */
  message: string;
  /**
   * Indicates whether the operation that caused the error should be retried.
   *
   * @remarks
   *
   * When `true`, the error is transient and the operation might succeed
   * if attempted again. When `false`, retrying the same operation is
   * unlikely to succeed without changes.
   */
  retryable: boolean;
  /**
   * The underlying error that caused this error, creating an error chain.
   *
   * @remarks
   *
   * This allows for proper error propagation and debugging by maintaining
   * the full context of how an error occurred through multiple layers
   * of an application.
   */
  source?: any | null | undefined;
};

/**
 * Durable progress for deployment updates
 */
export type DeploymentUpdateState = {
  active: DeploymentUpdateOperationSummary | null;
  next: DeploymentUpdateOperationSummary | null;
  latest: DeploymentUpdateOperationSummary | null;
};

export type Deployment = {
  /**
   * Unique identifier for the deployment.
   */
  id: string;
  /**
   * Deployment name.
   */
  name: string;
  /**
   * Public subdomain for auto-generated domains
   */
  publicSubdomain?: string | null | undefined;
  /**
   * Deployment status in the deployment lifecycle.
   *
   * @remarks
   *
   * For observe-only deployments with no release or stack state, `Running`
   * means the Operator is attached. Connectivity comes from `lastHeartbeatAt`;
   * resource health comes from inventory and resource heartbeat data.
   */
  status: DeploymentStatus;
  /**
   * Unique identifier for the project.
   */
  projectId: string;
  /**
   * Target platform for the deployment
   */
  platform: DeploymentPlatform;
  /**
   * Underlying cloud platform for Kubernetes deployments.
   */
  basePlatform?: DeploymentBasePlatform | null | undefined;
  /**
   * Cloud region or location for the deployment.
   */
  region?: string | null | undefined;
  /**
   * DeploymentState protocol version owned by the runtime/manager
   */
  deploymentProtocolVersion: number;
  /**
   * ID of deployment group this deployment belongs to
   */
  deploymentGroupId: string;
  /**
   * Operational purpose of this deployment within its customer environment.
   */
  purpose: DeploymentPurpose;
  /**
   * Cloud environment information
   */
  environmentInfo?:
    | DeploymentEnvironmentInfoGcp
    | DeploymentEnvironmentInfoAzure
    | DeploymentEnvironmentInfoLocal
    | DeploymentEnvironmentInfoAws
    | DeploymentEnvironmentInfoTest
    | any
    | null
    | undefined;
  /**
   * User-provided configuration (network, deployment model, approvals)
   */
  stackSettings: DeploymentStackSettings;
  /**
   * State of infrastructure components managed by this deployment
   */
  stackState?: DeploymentStackState | null | undefined;
  /**
   * Runtime metadata for deployment state persistence
   */
  runtimeMetadata?: DeploymentRuntimeMetadata | null | undefined;
  /**
   * ID of the currently deployed release (actual state)
   */
  currentReleaseId?: string | null | undefined;
  /**
   * ID of the desired release for deployment/update (desired state)
   */
  desiredReleaseId?: string | null | undefined;
  /**
   * ID of the pinned release
   */
  pinnedReleaseId?: string | null | undefined;
  releaseChannel: string;
  /**
   * Setup source that imported this deployment
   */
  importSource?: DeploymentImportSource | null | undefined;
  /**
   * Setup method that created the deployment record and owns setup-time resources.
   */
  setupMethod?: DeploymentSetupMethod1 | null | undefined;
  /**
   * Setup method metadata needed to guide privileged teardown.
   */
  setupMetadata?: { [k: string]: any | null } | null | undefined;
  /**
   * Imported setup target for compatibility checks
   */
  setupTarget?: string | null | undefined;
  /**
   * Imported setup compatibility fingerprint
   */
  setupFingerprint?: string | null | undefined;
  /**
   * Imported setup fingerprint algorithm version
   */
  setupFingerprintVersion?: number | null | undefined;
  /**
   * Display-only scope reported by the Operator manifest
   */
  operatorScope?: string | null | undefined;
  /**
   * Display-only permission tier reported by the Operator manifest
   */
  operatorPermission?: string | null | undefined;
  /**
   * Version reported by the Operator
   */
  operatorVersion?: string | null | undefined;
  /**
   * Capability state reported by the Operator
   */
  capabilities?: Array<OperatorCapabilityReport> | null | undefined;
  /**
   * Enabled-plugin-bundle-set hash the Operator reports having loaded
   */
  observedOperationsBundleHash?: string | null | undefined;
  /**
   * Operations the Operator reports as currently loaded
   */
  observedOperations?: Array<ReportedOperation> | null | undefined;
  /**
   * Whether a retry has been requested for a failed deployment
   */
  retryRequested: boolean;
  /**
   * Timestamp of the last received heartbeat from the deployment
   */
  lastHeartbeatAt?: Date | null | undefined;
  /**
   * Latest error information if the deployment is in a failed state
   */
  error?: DeploymentError | null | undefined;
  /**
   * Durable progress for deployment updates
   */
  updateState?: DeploymentUpdateState | undefined;
  createdAt: Date;
  updatedAt: Date;
  managerId: string;
  /**
   * Unique identifier for the workspace.
   */
  workspaceId: string;
};

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

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

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

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

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

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

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

/** @internal */
export const DeploymentEnvironmentInfoLocal$inboundSchema: z.ZodType<
  DeploymentEnvironmentInfoLocal,
  unknown
> = z.object({
  arch: z.string(),
  hostname: z.string(),
  os: z.string(),
  platform: DeploymentPlatformLocal$inboundSchema,
});

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

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

/** @internal */
export const DeploymentEnvironmentInfoAzure$inboundSchema: z.ZodType<
  DeploymentEnvironmentInfoAzure,
  unknown
> = z.object({
  location: z.string(),
  subscriptionId: z.string(),
  tenantId: z.string(),
  platform: DeploymentPlatformAzure$inboundSchema,
});

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

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

/** @internal */
export const DeploymentEnvironmentInfoGcp$inboundSchema: z.ZodType<
  DeploymentEnvironmentInfoGcp,
  unknown
> = z.object({
  projectId: z.string(),
  projectNumber: z.string(),
  region: z.string(),
  platform: DeploymentPlatformGcp$inboundSchema,
});

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

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

/** @internal */
export const DeploymentEnvironmentInfoAws$inboundSchema: z.ZodType<
  DeploymentEnvironmentInfoAws,
  unknown
> = z.object({
  accountId: z.string(),
  region: z.string(),
  platform: DeploymentPlatformAws$inboundSchema,
});

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

/** @internal */
export const DeploymentEnvironmentInfoUnion$inboundSchema: z.ZodType<
  DeploymentEnvironmentInfoUnion,
  unknown
> = z.union([
  z.lazy(() => DeploymentEnvironmentInfoGcp$inboundSchema),
  z.lazy(() => DeploymentEnvironmentInfoAzure$inboundSchema),
  z.lazy(() => DeploymentEnvironmentInfoLocal$inboundSchema),
  z.lazy(() => DeploymentEnvironmentInfoAws$inboundSchema),
  z.lazy(() => DeploymentEnvironmentInfoTest$inboundSchema),
  z.any(),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const DeploymentDomainsCertificate$inboundSchema: z.ZodType<
  DeploymentDomainsCertificate,
  unknown
> = z.object({
  aws: z.nullable(z.union([z.lazy(() => DeploymentAws$inboundSchema), z.any()]))
    .optional(),
  azure: z.nullable(
    z.union([
      z.lazy(() => DeploymentAzureStackSettings$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  gcp: z.nullable(
    z.union([z.lazy(() => DeploymentGcpStackSettings$inboundSchema), z.any()]),
  ).optional(),
  kubernetes: z.nullable(
    z.union([z.lazy(() => DeploymentDomainsKubernetes$inboundSchema), z.any()]),
  ).optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const DeploymentCertificateUnion2$inboundSchema: z.ZodType<
  DeploymentCertificateUnion2,
  unknown
> = z.union([
  z.lazy(() => DeploymentCertificateTLSSecretRef2$inboundSchema),
  z.lazy(() => DeploymentCertificateManagedAcmImport2$inboundSchema),
  z.lazy(() => DeploymentCertificateAwsAcmArn2$inboundSchema),
  z.lazy(() => DeploymentCertificateManagedTLSSecret2$inboundSchema),
  z.lazy(() => DeploymentCertificateNone2$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const DeploymentExposureCustom$inboundSchema: z.ZodType<
  DeploymentExposureCustom,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => DeploymentCertificateTLSSecretRef2$inboundSchema),
    z.lazy(() => DeploymentCertificateManagedAcmImport2$inboundSchema),
    z.lazy(() => DeploymentCertificateAwsAcmArn2$inboundSchema),
    z.lazy(() => DeploymentCertificateManagedTLSSecret2$inboundSchema),
    z.lazy(() => DeploymentCertificateNone2$inboundSchema),
  ]),
  domain: z.string(),
  mode: DeploymentModeCustom$inboundSchema,
  route: z.union([
    z.lazy(() => DeploymentRouteIngress2$inboundSchema),
    z.lazy(() => DeploymentRouteGateway2$inboundSchema),
  ]),
});

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const DeploymentCertificateUnion1$inboundSchema: z.ZodType<
  DeploymentCertificateUnion1,
  unknown
> = z.union([
  z.lazy(() => DeploymentCertificateTLSSecretRef1$inboundSchema),
  z.lazy(() => DeploymentCertificateManagedAcmImport1$inboundSchema),
  z.lazy(() => DeploymentCertificateAwsAcmArn1$inboundSchema),
  z.lazy(() => DeploymentCertificateManagedTLSSecret1$inboundSchema),
  z.lazy(() => DeploymentCertificateNone1$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const DeploymentExposureGenerated$inboundSchema: z.ZodType<
  DeploymentExposureGenerated,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => DeploymentCertificateTLSSecretRef1$inboundSchema),
    z.lazy(() => DeploymentCertificateManagedAcmImport1$inboundSchema),
    z.lazy(() => DeploymentCertificateAwsAcmArn1$inboundSchema),
    z.lazy(() => DeploymentCertificateManagedTLSSecret1$inboundSchema),
    z.lazy(() => DeploymentCertificateNone1$inboundSchema),
  ]),
  mode: DeploymentModeGenerated$inboundSchema,
  route: z.union([
    z.lazy(() => DeploymentRouteIngress1$inboundSchema),
    z.lazy(() => DeploymentRouteGateway1$inboundSchema),
  ]),
});

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

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

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

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

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

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

/** @internal */
export const DeploymentKubernetes$inboundSchema: z.ZodType<
  DeploymentKubernetes,
  unknown
> = z.object({
  cluster: z.nullable(
    z.union([z.lazy(() => DeploymentCluster$inboundSchema), z.any()]),
  ).optional(),
  exposure: z.nullable(
    z.union([
      z.lazy(() => DeploymentExposureCustom$inboundSchema),
      z.lazy(() => DeploymentExposureGenerated$inboundSchema),
      z.lazy(() => DeploymentExposureDisabled$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const DeploymentNetworkUnion$inboundSchema: z.ZodType<
  DeploymentNetworkUnion,
  unknown
> = z.union([
  z.lazy(() => DeploymentNetworkByoVpcAws$inboundSchema),
  z.lazy(() => DeploymentNetworkByoVpcGcp$inboundSchema),
  z.lazy(() => DeploymentNetworkByoVnetAzure$inboundSchema),
  z.lazy(() => DeploymentNetworkUseDefault$inboundSchema),
  z.lazy(() => DeploymentNetworkCreate$inboundSchema),
  z.any(),
]);

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

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

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

/** @internal */
export const DeploymentStackSettings$inboundSchema: z.ZodType<
  DeploymentStackSettings,
  unknown
> = z.object({
  compute: z.nullable(
    z.union([z.lazy(() => DeploymentCompute$inboundSchema), z.any()]),
  ).optional(),
  deploymentModel: DeploymentDeploymentModel$inboundSchema.optional(),
  domains: z.nullable(
    z.union([z.lazy(() => DeploymentDomains$inboundSchema), z.any()]),
  ).optional(),
  externalBindings: z.nullable(
    z.lazy(() => DeploymentExternalBindings$inboundSchema),
  ).optional(),
  heartbeats: DeploymentHeartbeats$inboundSchema.optional(),
  kubernetes: z.nullable(
    z.union([z.lazy(() => DeploymentKubernetes$inboundSchema), z.any()]),
  ).optional(),
  network: z.nullable(
    z.union([
      z.lazy(() => DeploymentNetworkByoVpcAws$inboundSchema),
      z.lazy(() => DeploymentNetworkByoVpcGcp$inboundSchema),
      z.lazy(() => DeploymentNetworkByoVnetAzure$inboundSchema),
      z.lazy(() => DeploymentNetworkUseDefault$inboundSchema),
      z.lazy(() => DeploymentNetworkCreate$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  publicEndpoints: z.nullable(
    z.record(z.string(), z.record(z.string(), z.string())),
  ).optional(),
  telemetry: DeploymentTelemetry$inboundSchema.optional(),
  updates: DeploymentUpdates$inboundSchema.optional(),
});

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

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

/** @internal */
export const DeploymentStackStateConfig$inboundSchema: z.ZodType<
  DeploymentStackStateConfig,
  unknown
> = collectExtraKeys$(
  z.object({
    id: z.string(),
    type: z.string(),
  }).catchall(z.any()),
  "additionalProperties",
  true,
);

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

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

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

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

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

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

/** @internal */
export const DeploymentErrorStackState$inboundSchema: z.ZodType<
  DeploymentErrorStackState,
  unknown
> = z.object({
  code: z.string(),
  context: z.nullable(z.any()).optional(),
  hint: z.nullable(z.string()).optional(),
  httpStatusCode: z.nullable(z.int()).optional(),
  internal: z.boolean(),
  message: z.string(),
  retryable: z.boolean().default(false),
  source: z.nullable(z.any()).optional(),
});

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

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

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

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

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

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

/** @internal */
export const DeploymentOutputs$inboundSchema: z.ZodType<
  DeploymentOutputs,
  unknown
> = collectExtraKeys$(
  z.object({
    type: z.string(),
  }).catchall(z.any()),
  "additionalProperties",
  true,
);

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

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

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

/** @internal */
export const DeploymentPreviousConfig$inboundSchema: z.ZodType<
  DeploymentPreviousConfig,
  unknown
> = collectExtraKeys$(
  z.object({
    id: z.string(),
    type: z.string(),
  }).catchall(z.any()),
  "additionalProperties",
  true,
);

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

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

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

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

/** @internal */
export const DeploymentStackStateResources$inboundSchema: z.ZodType<
  DeploymentStackStateResources,
  unknown
> = z.object({
  _internal: z.nullable(z.any()).optional(),
  config: z.lazy(() => DeploymentStackStateConfig$inboundSchema),
  controllerPlatform: z.nullable(
    z.union([DeploymentControllerPlatformEnum$inboundSchema, z.any()]),
  ).optional(),
  dependencies: z.array(
    z.lazy(() => DeploymentStackStateDependency$inboundSchema),
  ).optional(),
  error: z.nullable(
    z.union([z.lazy(() => DeploymentErrorStackState$inboundSchema), z.any()]),
  ).optional(),
  lastFailedState: z.nullable(z.any()).optional(),
  lifecycle: z.nullable(
    z.union([DeploymentLifecycleStackStateEnum$inboundSchema, z.any()]),
  ).optional(),
  outputs: z.nullable(
    z.union([z.lazy(() => DeploymentOutputs$inboundSchema), z.any()]),
  ).optional(),
  previousConfig: z.nullable(
    z.union([z.lazy(() => DeploymentPreviousConfig$inboundSchema), z.any()]),
  ).optional(),
  remoteBindingParams: z.nullable(z.any()).optional(),
  retryAttempt: z.int().optional(),
  status: DeploymentStackStateStatus$inboundSchema,
  type: z.string(),
}).transform((v) => {
  return remap$(v, {
    "_internal": "internal",
  });
});

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

/** @internal */
export const DeploymentStackState$inboundSchema: z.ZodType<
  DeploymentStackState,
  unknown
> = z.object({
  platform: DeploymentStackStatePlatform$inboundSchema,
  resourcePrefix: z.string(),
  resources: z.record(
    z.string(),
    z.lazy(() => DeploymentStackStateResources$inboundSchema),
  ),
});

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackDefaultStringList$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackDefaultStringList, unknown> = z
    .object({
      type: DeploymentPendingPreparedStackTypeStringList$inboundSchema,
      value: z.array(z.string()),
    });

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackDefaultUnion$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackDefaultUnion, unknown> = z.union([
    z.lazy(() => DeploymentPendingPreparedStackDefaultString$inboundSchema),
    z.lazy(() => DeploymentPendingPreparedStackDefaultNumber$inboundSchema),
    z.lazy(() => DeploymentPendingPreparedStackDefaultBoolean$inboundSchema),
    z.lazy(() => DeploymentPendingPreparedStackDefaultStringList$inboundSchema),
    z.any(),
  ]);

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackEnv$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackEnv,
  unknown
> = z.object({
  name: z.string(),
  targetResources: z.nullable(z.array(z.string())).optional(),
  type: z.nullable(
    z.union([DeploymentPendingPreparedStackTypeEnvEnum$inboundSchema, z.any()]),
  ).optional(),
});

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackValidation$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackValidation,
  unknown
> = z.object({
  format: z.nullable(z.string()).optional(),
  max: z.nullable(z.string()).optional(),
  maxItems: z.nullable(z.int()).optional(),
  maxLength: z.nullable(z.int()).optional(),
  min: z.nullable(z.string()).optional(),
  minItems: z.nullable(z.int()).optional(),
  minLength: z.nullable(z.int()).optional(),
  pattern: z.nullable(z.string()).optional(),
  values: z.nullable(z.array(z.string())).optional(),
});

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackInput$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackInput,
  unknown
> = z.object({
  default: z.nullable(
    z.union([
      z.lazy(() => DeploymentPendingPreparedStackDefaultString$inboundSchema),
      z.lazy(() => DeploymentPendingPreparedStackDefaultNumber$inboundSchema),
      z.lazy(() => DeploymentPendingPreparedStackDefaultBoolean$inboundSchema),
      z.lazy(() =>
        DeploymentPendingPreparedStackDefaultStringList$inboundSchema
      ),
      z.any(),
    ]),
  ).optional(),
  description: z.string(),
  env: z.array(z.lazy(() => DeploymentPendingPreparedStackEnv$inboundSchema))
    .optional(),
  id: z.string(),
  kind: DeploymentPendingPreparedStackKind$inboundSchema,
  label: z.string(),
  placeholder: z.nullable(z.string()).optional(),
  platforms: z.nullable(
    z.array(DeploymentPendingPreparedStackPlatform$inboundSchema),
  ).optional(),
  providedBy: z.array(DeploymentPendingPreparedStackProvidedBy$inboundSchema),
  required: z.boolean(),
  validation: z.nullable(
    z.union([
      z.lazy(() => DeploymentPendingPreparedStackValidation$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideAwResource$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverrideAwResource, unknown> = z
    .object({
      condition: z.nullable(
        z.record(z.string(), z.record(z.string(), z.string())),
      ).optional(),
      resources: z.array(z.string()),
    });

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideAwStack$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverrideAwStack, unknown> = z.object({
    condition: z.nullable(
      z.record(z.string(), z.record(z.string(), z.string())),
    ).optional(),
    resources: z.array(z.string()),
  });

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideAwBinding$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverrideAwBinding, unknown> = z
    .object({
      resource: z.lazy(() =>
        DeploymentPendingPreparedStackOverrideAwResource$inboundSchema
      ).optional(),
      stack: z.lazy(() =>
        DeploymentPendingPreparedStackOverrideAwStack$inboundSchema
      ).optional(),
    });

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

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideAwGrant$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverrideAwGrant, unknown> = z.object({
    actions: z.nullable(z.array(z.string())).optional(),
    dataActions: z.nullable(z.array(z.string())).optional(),
    permissions: z.nullable(z.array(z.string())).optional(),
    predefinedRoles: z.nullable(z.array(z.string())).optional(),
    residualPermissions: z.nullable(z.array(z.string())).optional(),
  });

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideAw$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackOverrideAw,
  unknown
> = z.object({
  binding: z.lazy(() =>
    DeploymentPendingPreparedStackOverrideAwBinding$inboundSchema
  ),
  description: z.nullable(z.string()).optional(),
  effect: DeploymentPendingPreparedStackOverrideEffect$inboundSchema.optional(),
  grant: z.lazy(() =>
    DeploymentPendingPreparedStackOverrideAwGrant$inboundSchema
  ),
  label: z.nullable(z.string()).optional(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideAzureBinding$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverrideAzureBinding, unknown> = z
    .object({
      resource: z.lazy(() =>
        DeploymentPendingPreparedStackOverrideAzureResource$inboundSchema
      ).optional(),
      stack: z.lazy(() =>
        DeploymentPendingPreparedStackOverrideAzureStack$inboundSchema
      ).optional(),
    });

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideAzureGrant$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverrideAzureGrant, unknown> = z
    .object({
      actions: z.nullable(z.array(z.string())).optional(),
      dataActions: z.nullable(z.array(z.string())).optional(),
      permissions: z.nullable(z.array(z.string())).optional(),
      predefinedRoles: z.nullable(z.array(z.string())).optional(),
      residualPermissions: z.nullable(z.array(z.string())).optional(),
    });

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideAzure$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverrideAzure, unknown> = z.object({
    binding: z.lazy(() =>
      DeploymentPendingPreparedStackOverrideAzureBinding$inboundSchema
    ),
    description: z.nullable(z.string()).optional(),
    grant: z.lazy(() =>
      DeploymentPendingPreparedStackOverrideAzureGrant$inboundSchema
    ),
    label: z.nullable(z.string()).optional(),
  });

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

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideGcpResource$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverrideGcpResource, unknown> = z
    .object({
      condition: z.nullable(
        z.union([
          z.lazy(() =>
            DeploymentPendingPreparedStackOverrideConditionResource$inboundSchema
          ),
          z.any(),
        ]),
      ).optional(),
      scope: z.string(),
    });

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

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideGcpStack$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverrideGcpStack, unknown> = z.object(
    {
      condition: z.nullable(z.union([
        z.lazy(() =>
          DeploymentPendingPreparedStackOverrideConditionStack$inboundSchema
        ),
        z.any(),
      ])).optional(),
      scope: z.string(),
    },
  );

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideGcpBinding$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverrideGcpBinding, unknown> = z
    .object({
      resource: z.lazy(() =>
        DeploymentPendingPreparedStackOverrideGcpResource$inboundSchema
      ).optional(),
      stack: z.lazy(() =>
        DeploymentPendingPreparedStackOverrideGcpStack$inboundSchema
      ).optional(),
    });

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideGcpGrant$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverrideGcpGrant, unknown> = z.object(
    {
      actions: z.nullable(z.array(z.string())).optional(),
      dataActions: z.nullable(z.array(z.string())).optional(),
      permissions: z.nullable(z.array(z.string())).optional(),
      predefinedRoles: z.nullable(z.array(z.string())).optional(),
      residualPermissions: z.nullable(z.array(z.string())).optional(),
    },
  );

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

/** @internal */
export const DeploymentPendingPreparedStackOverrideGcp$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackOverrideGcp,
  unknown
> = z.object({
  binding: z.lazy(() =>
    DeploymentPendingPreparedStackOverrideGcpBinding$inboundSchema
  ),
  description: z.nullable(z.string()).optional(),
  grant: z.lazy(() =>
    DeploymentPendingPreparedStackOverrideGcpGrant$inboundSchema
  ),
  label: z.nullable(z.string()).optional(),
});

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

/** @internal */
export const DeploymentPendingPreparedStackOverridePlatforms$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackOverridePlatforms, unknown> = z
    .object({
      aws: z.nullable(
        z.array(z.lazy(() =>
          DeploymentPendingPreparedStackOverrideAw$inboundSchema
        )),
      ).optional(),
      azure: z.nullable(
        z.array(z.lazy(() =>
          DeploymentPendingPreparedStackOverrideAzure$inboundSchema
        )),
      ).optional(),
      gcp: z.nullable(
        z.array(z.lazy(() =>
          DeploymentPendingPreparedStackOverrideGcp$inboundSchema
        )),
      ).optional(),
    });

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

/** @internal */
export const DeploymentPendingPreparedStackOverride$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackOverride,
  unknown
> = z.object({
  description: z.string(),
  id: z.string(),
  platforms: z.lazy(() =>
    DeploymentPendingPreparedStackOverridePlatforms$inboundSchema
  ),
});

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackManagement2$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackManagement2,
  unknown
> = z.object({
  override: z.record(
    z.string(),
    z.array(z.union([
      z.lazy(() => DeploymentPendingPreparedStackOverride$inboundSchema),
      z.string(),
    ])),
  ),
});

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

/** @internal */
export const DeploymentPendingPreparedStackExtendAwResource$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackExtendAwResource, unknown> = z.object(
    {
      condition: z.nullable(
        z.record(z.string(), z.record(z.string(), z.string())),
      ).optional(),
      resources: z.array(z.string()),
    },
  );

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

/** @internal */
export const DeploymentPendingPreparedStackExtendAwStack$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackExtendAwStack, unknown> = z.object({
    condition: z.nullable(
      z.record(z.string(), z.record(z.string(), z.string())),
    ).optional(),
    resources: z.array(z.string()),
  });

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

/** @internal */
export const DeploymentPendingPreparedStackExtendAwBinding$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackExtendAwBinding, unknown> = z.object({
    resource: z.lazy(() =>
      DeploymentPendingPreparedStackExtendAwResource$inboundSchema
    ).optional(),
    stack: z.lazy(() =>
      DeploymentPendingPreparedStackExtendAwStack$inboundSchema
    ).optional(),
  });

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

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

/** @internal */
export const DeploymentPendingPreparedStackExtendAwGrant$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackExtendAwGrant, unknown> = z.object({
    actions: z.nullable(z.array(z.string())).optional(),
    dataActions: z.nullable(z.array(z.string())).optional(),
    permissions: z.nullable(z.array(z.string())).optional(),
    predefinedRoles: z.nullable(z.array(z.string())).optional(),
    residualPermissions: z.nullable(z.array(z.string())).optional(),
  });

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

/** @internal */
export const DeploymentPendingPreparedStackExtendAw$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackExtendAw,
  unknown
> = z.object({
  binding: z.lazy(() =>
    DeploymentPendingPreparedStackExtendAwBinding$inboundSchema
  ),
  description: z.nullable(z.string()).optional(),
  effect: DeploymentPendingPreparedStackExtendEffect$inboundSchema.optional(),
  grant: z.lazy(() =>
    DeploymentPendingPreparedStackExtendAwGrant$inboundSchema
  ),
  label: z.nullable(z.string()).optional(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackExtendAzureBinding$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackExtendAzureBinding, unknown> = z
    .object({
      resource: z.lazy(() =>
        DeploymentPendingPreparedStackExtendAzureResource$inboundSchema
      ).optional(),
      stack: z.lazy(() =>
        DeploymentPendingPreparedStackExtendAzureStack$inboundSchema
      ).optional(),
    });

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

/** @internal */
export const DeploymentPendingPreparedStackExtendAzureGrant$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackExtendAzureGrant, unknown> = z.object(
    {
      actions: z.nullable(z.array(z.string())).optional(),
      dataActions: z.nullable(z.array(z.string())).optional(),
      permissions: z.nullable(z.array(z.string())).optional(),
      predefinedRoles: z.nullable(z.array(z.string())).optional(),
      residualPermissions: z.nullable(z.array(z.string())).optional(),
    },
  );

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

/** @internal */
export const DeploymentPendingPreparedStackExtendAzure$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackExtendAzure,
  unknown
> = z.object({
  binding: z.lazy(() =>
    DeploymentPendingPreparedStackExtendAzureBinding$inboundSchema
  ),
  description: z.nullable(z.string()).optional(),
  grant: z.lazy(() =>
    DeploymentPendingPreparedStackExtendAzureGrant$inboundSchema
  ),
  label: z.nullable(z.string()).optional(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackExtendGcpResource$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackExtendGcpResource, unknown> = z
    .object({
      condition: z.nullable(
        z.union([
          z.lazy(() =>
            DeploymentPendingPreparedStackExtendConditionResource$inboundSchema
          ),
          z.any(),
        ]),
      ).optional(),
      scope: z.string(),
    });

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

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackExtendGcpStack$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackExtendGcpStack, unknown> = z.object({
    condition: z.nullable(
      z.union([
        z.lazy(() =>
          DeploymentPendingPreparedStackExtendConditionStack$inboundSchema
        ),
        z.any(),
      ]),
    ).optional(),
    scope: z.string(),
  });

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

/** @internal */
export const DeploymentPendingPreparedStackExtendGcpBinding$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackExtendGcpBinding, unknown> = z.object(
    {
      resource: z.lazy(() =>
        DeploymentPendingPreparedStackExtendGcpResource$inboundSchema
      ).optional(),
      stack: z.lazy(() =>
        DeploymentPendingPreparedStackExtendGcpStack$inboundSchema
      ).optional(),
    },
  );

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

/** @internal */
export const DeploymentPendingPreparedStackExtendGcpGrant$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackExtendGcpGrant, unknown> = z.object({
    actions: z.nullable(z.array(z.string())).optional(),
    dataActions: z.nullable(z.array(z.string())).optional(),
    permissions: z.nullable(z.array(z.string())).optional(),
    predefinedRoles: z.nullable(z.array(z.string())).optional(),
    residualPermissions: z.nullable(z.array(z.string())).optional(),
  });

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

/** @internal */
export const DeploymentPendingPreparedStackExtendGcp$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackExtendGcp,
  unknown
> = z.object({
  binding: z.lazy(() =>
    DeploymentPendingPreparedStackExtendGcpBinding$inboundSchema
  ),
  description: z.nullable(z.string()).optional(),
  grant: z.lazy(() =>
    DeploymentPendingPreparedStackExtendGcpGrant$inboundSchema
  ),
  label: z.nullable(z.string()).optional(),
});

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

/** @internal */
export const DeploymentPendingPreparedStackExtendPlatforms$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackExtendPlatforms, unknown> = z.object({
    aws: z.nullable(
      z.array(
        z.lazy(() => DeploymentPendingPreparedStackExtendAw$inboundSchema),
      ),
    ).optional(),
    azure: z.nullable(
      z.array(z.lazy(() =>
        DeploymentPendingPreparedStackExtendAzure$inboundSchema
      )),
    ).optional(),
    gcp: z.nullable(
      z.array(
        z.lazy(() => DeploymentPendingPreparedStackExtendGcp$inboundSchema),
      ),
    ).optional(),
  });

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

/** @internal */
export const DeploymentPendingPreparedStackExtend$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackExtend,
  unknown
> = z.object({
  description: z.string(),
  id: z.string(),
  platforms: z.lazy(() =>
    DeploymentPendingPreparedStackExtendPlatforms$inboundSchema
  ),
});

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackManagement1$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackManagement1,
  unknown
> = z.object({
  extend: z.record(
    z.string(),
    z.array(z.union([
      z.lazy(() => DeploymentPendingPreparedStackExtend$inboundSchema),
      z.string(),
    ])),
  ),
});

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

/** @internal */
export const DeploymentPendingPreparedStackManagementUnion$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackManagementUnion, unknown> = z.union([
    z.lazy(() => DeploymentPendingPreparedStackManagement1$inboundSchema),
    z.lazy(() => DeploymentPendingPreparedStackManagement2$inboundSchema),
    DeploymentPendingPreparedStackManagementEnum$inboundSchema,
  ]);

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

/** @internal */
export const DeploymentPendingPreparedStackProfileAwResource$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfileAwResource, unknown> = z
    .object({
      condition: z.nullable(
        z.record(z.string(), z.record(z.string(), z.string())),
      ).optional(),
      resources: z.array(z.string()),
    });

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

/** @internal */
export const DeploymentPendingPreparedStackProfileAwStack$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfileAwStack, unknown> = z.object({
    condition: z.nullable(
      z.record(z.string(), z.record(z.string(), z.string())),
    ).optional(),
    resources: z.array(z.string()),
  });

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

/** @internal */
export const DeploymentPendingPreparedStackProfileAwBinding$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfileAwBinding, unknown> = z.object(
    {
      resource: z.lazy(() =>
        DeploymentPendingPreparedStackProfileAwResource$inboundSchema
      ).optional(),
      stack: z.lazy(() =>
        DeploymentPendingPreparedStackProfileAwStack$inboundSchema
      ).optional(),
    },
  );

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

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

/** @internal */
export const DeploymentPendingPreparedStackProfileAwGrant$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfileAwGrant, unknown> = z.object({
    actions: z.nullable(z.array(z.string())).optional(),
    dataActions: z.nullable(z.array(z.string())).optional(),
    permissions: z.nullable(z.array(z.string())).optional(),
    predefinedRoles: z.nullable(z.array(z.string())).optional(),
    residualPermissions: z.nullable(z.array(z.string())).optional(),
  });

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

/** @internal */
export const DeploymentPendingPreparedStackProfileAw$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackProfileAw,
  unknown
> = z.object({
  binding: z.lazy(() =>
    DeploymentPendingPreparedStackProfileAwBinding$inboundSchema
  ),
  description: z.nullable(z.string()).optional(),
  effect: DeploymentPendingPreparedStackProfileEffect$inboundSchema.optional(),
  grant: z.lazy(() =>
    DeploymentPendingPreparedStackProfileAwGrant$inboundSchema
  ),
  label: z.nullable(z.string()).optional(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackProfileAzureBinding$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfileAzureBinding, unknown> = z
    .object({
      resource: z.lazy(() =>
        DeploymentPendingPreparedStackProfileAzureResource$inboundSchema
      ).optional(),
      stack: z.lazy(() =>
        DeploymentPendingPreparedStackProfileAzureStack$inboundSchema
      ).optional(),
    });

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

/** @internal */
export const DeploymentPendingPreparedStackProfileAzureGrant$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfileAzureGrant, unknown> = z
    .object({
      actions: z.nullable(z.array(z.string())).optional(),
      dataActions: z.nullable(z.array(z.string())).optional(),
      permissions: z.nullable(z.array(z.string())).optional(),
      predefinedRoles: z.nullable(z.array(z.string())).optional(),
      residualPermissions: z.nullable(z.array(z.string())).optional(),
    });

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

/** @internal */
export const DeploymentPendingPreparedStackProfileAzure$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfileAzure, unknown> = z.object({
    binding: z.lazy(() =>
      DeploymentPendingPreparedStackProfileAzureBinding$inboundSchema
    ),
    description: z.nullable(z.string()).optional(),
    grant: z.lazy(() =>
      DeploymentPendingPreparedStackProfileAzureGrant$inboundSchema
    ),
    label: z.nullable(z.string()).optional(),
  });

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

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackProfileGcpResource$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfileGcpResource, unknown> = z
    .object({
      condition: z.nullable(
        z.union([
          z.lazy(() =>
            DeploymentPendingPreparedStackProfileConditionResource$inboundSchema
          ),
          z.any(),
        ]),
      ).optional(),
      scope: z.string(),
    });

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

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackProfileGcpStack$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfileGcpStack, unknown> = z.object({
    condition: z.nullable(
      z.union([
        z.lazy(() =>
          DeploymentPendingPreparedStackProfileConditionStack$inboundSchema
        ),
        z.any(),
      ]),
    ).optional(),
    scope: z.string(),
  });

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

/** @internal */
export const DeploymentPendingPreparedStackProfileGcpBinding$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfileGcpBinding, unknown> = z
    .object({
      resource: z.lazy(() =>
        DeploymentPendingPreparedStackProfileGcpResource$inboundSchema
      ).optional(),
      stack: z.lazy(() =>
        DeploymentPendingPreparedStackProfileGcpStack$inboundSchema
      ).optional(),
    });

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

/** @internal */
export const DeploymentPendingPreparedStackProfileGcpGrant$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfileGcpGrant, unknown> = z.object({
    actions: z.nullable(z.array(z.string())).optional(),
    dataActions: z.nullable(z.array(z.string())).optional(),
    permissions: z.nullable(z.array(z.string())).optional(),
    predefinedRoles: z.nullable(z.array(z.string())).optional(),
    residualPermissions: z.nullable(z.array(z.string())).optional(),
  });

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

/** @internal */
export const DeploymentPendingPreparedStackProfileGcp$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackProfileGcp,
  unknown
> = z.object({
  binding: z.lazy(() =>
    DeploymentPendingPreparedStackProfileGcpBinding$inboundSchema
  ),
  description: z.nullable(z.string()).optional(),
  grant: z.lazy(() =>
    DeploymentPendingPreparedStackProfileGcpGrant$inboundSchema
  ),
  label: z.nullable(z.string()).optional(),
});

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

/** @internal */
export const DeploymentPendingPreparedStackProfilePlatforms$inboundSchema:
  z.ZodType<DeploymentPendingPreparedStackProfilePlatforms, unknown> = z.object(
    {
      aws: z.nullable(z.array(z.lazy(() =>
        DeploymentPendingPreparedStackProfileAw$inboundSchema
      ))).optional(),
      azure: z.nullable(z.array(z.lazy(() =>
        DeploymentPendingPreparedStackProfileAzure$inboundSchema
      ))).optional(),
      gcp: z.nullable(z.array(z.lazy(() =>
        DeploymentPendingPreparedStackProfileGcp$inboundSchema
      ))).optional(),
    },
  );

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

/** @internal */
export const DeploymentPendingPreparedStackProfile$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackProfile,
  unknown
> = z.object({
  description: z.string(),
  id: z.string(),
  platforms: z.lazy(() =>
    DeploymentPendingPreparedStackProfilePlatforms$inboundSchema
  ),
});

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackPermissions$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackPermissions,
  unknown
> = z.object({
  management: z.union([
    z.lazy(() => DeploymentPendingPreparedStackManagement1$inboundSchema),
    z.lazy(() => DeploymentPendingPreparedStackManagement2$inboundSchema),
    DeploymentPendingPreparedStackManagementEnum$inboundSchema,
  ]).optional(),
  profiles: z.record(
    z.string(),
    z.record(
      z.string(),
      z.array(
        z.union([
          z.lazy(() => DeploymentPendingPreparedStackProfile$inboundSchema),
          z.string(),
        ]),
      ),
    ),
  ),
});

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

/** @internal */
export const DeploymentPendingPreparedStackConfig$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackConfig,
  unknown
> = collectExtraKeys$(
  z.object({
    id: z.string(),
    type: z.string(),
  }).catchall(z.any()),
  "additionalProperties",
  true,
);

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

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

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

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

/** @internal */
export const DeploymentPendingPreparedStackResources$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStackResources,
  unknown
> = z.object({
  config: z.lazy(() => DeploymentPendingPreparedStackConfig$inboundSchema),
  dependencies: z.array(
    z.lazy(() => DeploymentPendingPreparedStackDependency$inboundSchema),
  ),
  enabledWhen: z.nullable(z.string()).optional(),
  lifecycle: DeploymentPendingPreparedStackLifecycle$inboundSchema,
  remoteAccess: z.boolean().optional(),
});

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

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

/** @internal */
export const DeploymentPendingPreparedStack$inboundSchema: z.ZodType<
  DeploymentPendingPreparedStack,
  unknown
> = z.object({
  id: z.string(),
  inputs: z.array(
    z.lazy(() => DeploymentPendingPreparedStackInput$inboundSchema),
  ).optional(),
  permissions: z.lazy(() =>
    DeploymentPendingPreparedStackPermissions$inboundSchema
  ).optional(),
  resources: z.record(
    z.string(),
    z.lazy(() => DeploymentPendingPreparedStackResources$inboundSchema),
  ),
  supportedPlatforms: z.nullable(
    z.array(DeploymentPendingPreparedStackSupportedPlatform$inboundSchema),
  ).optional(),
});

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

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

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

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

/** @internal */
export const DeploymentPreparedStackDefaultStringList$inboundSchema: z.ZodType<
  DeploymentPreparedStackDefaultStringList,
  unknown
> = z.object({
  type: DeploymentPreparedStackTypeStringList$inboundSchema,
  value: z.array(z.string()),
});

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const DeploymentPreparedStackDefaultUnion$inboundSchema: z.ZodType<
  DeploymentPreparedStackDefaultUnion,
  unknown
> = z.union([
  z.lazy(() => DeploymentPreparedStackDefaultString$inboundSchema),
  z.lazy(() => DeploymentPreparedStackDefaultNumber$inboundSchema),
  z.lazy(() => DeploymentPreparedStackDefaultBoolean$inboundSchema),
  z.lazy(() => DeploymentPreparedStackDefaultStringList$inboundSchema),
  z.any(),
]);

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

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

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

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

/** @internal */
export const DeploymentPreparedStackEnv$inboundSchema: z.ZodType<
  DeploymentPreparedStackEnv,
  unknown
> = z.object({
  name: z.string(),
  targetResources: z.nullable(z.array(z.string())).optional(),
  type: z.nullable(
    z.union([DeploymentPreparedStackTypeEnvEnum$inboundSchema, z.any()]),
  ).optional(),
});

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

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

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

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

/** @internal */
export const DeploymentPreparedStackValidation$inboundSchema: z.ZodType<
  DeploymentPreparedStackValidation,
  unknown
> = z.object({
  format: z.nullable(z.string()).optional(),
  max: z.nullable(z.string()).optional(),
  maxItems: z.nullable(z.int()).optional(),
  maxLength: z.nullable(z.int()).optional(),
  min: z.nullable(z.string()).optional(),
  minItems: z.nullable(z.int()).optional(),
  minLength: z.nullable(z.int()).optional(),
  pattern: z.nullable(z.string()).optional(),
  values: z.nullable(z.array(z.string())).optional(),
});

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

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

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

/** @internal */
export const DeploymentPreparedStackInput$inboundSchema: z.ZodType<
  DeploymentPreparedStackInput,
  unknown
> = z.object({
  default: z.nullable(
    z.union([
      z.lazy(() => DeploymentPreparedStackDefaultString$inboundSchema),
      z.lazy(() => DeploymentPreparedStackDefaultNumber$inboundSchema),
      z.lazy(() => DeploymentPreparedStackDefaultBoolean$inboundSchema),
      z.lazy(() => DeploymentPreparedStackDefaultStringList$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  description: z.string(),
  env: z.array(z.lazy(() => DeploymentPreparedStackEnv$inboundSchema))
    .optional(),
  id: z.string(),
  kind: DeploymentPreparedStackKind$inboundSchema,
  label: z.string(),
  placeholder: z.nullable(z.string()).optional(),
  platforms: z.nullable(z.array(DeploymentPreparedStackPlatform$inboundSchema))
    .optional(),
  providedBy: z.array(DeploymentPreparedStackProvidedBy$inboundSchema),
  required: z.boolean(),
  validation: z.nullable(
    z.union([
      z.lazy(() => DeploymentPreparedStackValidation$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

/** @internal */
export const DeploymentPreparedStackOverrideAwResource$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverrideAwResource,
  unknown
> = z.object({
  condition: z.nullable(z.record(z.string(), z.record(z.string(), z.string())))
    .optional(),
  resources: z.array(z.string()),
});

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

/** @internal */
export const DeploymentPreparedStackOverrideAwStack$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverrideAwStack,
  unknown
> = z.object({
  condition: z.nullable(z.record(z.string(), z.record(z.string(), z.string())))
    .optional(),
  resources: z.array(z.string()),
});

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

/** @internal */
export const DeploymentPreparedStackOverrideAwBinding$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverrideAwBinding,
  unknown
> = z.object({
  resource: z.lazy(() =>
    DeploymentPreparedStackOverrideAwResource$inboundSchema
  ).optional(),
  stack: z.lazy(() => DeploymentPreparedStackOverrideAwStack$inboundSchema)
    .optional(),
});

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

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

/** @internal */
export const DeploymentPreparedStackOverrideAwGrant$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverrideAwGrant,
  unknown
> = z.object({
  actions: z.nullable(z.array(z.string())).optional(),
  dataActions: z.nullable(z.array(z.string())).optional(),
  permissions: z.nullable(z.array(z.string())).optional(),
  predefinedRoles: z.nullable(z.array(z.string())).optional(),
  residualPermissions: z.nullable(z.array(z.string())).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackOverrideAw$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverrideAw,
  unknown
> = z.object({
  binding: z.lazy(() => DeploymentPreparedStackOverrideAwBinding$inboundSchema),
  description: z.nullable(z.string()).optional(),
  effect: DeploymentPreparedStackOverrideEffect$inboundSchema.optional(),
  grant: z.lazy(() => DeploymentPreparedStackOverrideAwGrant$inboundSchema),
  label: z.nullable(z.string()).optional(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPreparedStackOverrideAzureBinding$inboundSchema:
  z.ZodType<DeploymentPreparedStackOverrideAzureBinding, unknown> = z.object({
    resource: z.lazy(() =>
      DeploymentPreparedStackOverrideAzureResource$inboundSchema
    ).optional(),
    stack: z.lazy(() => DeploymentPreparedStackOverrideAzureStack$inboundSchema)
      .optional(),
  });

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

/** @internal */
export const DeploymentPreparedStackOverrideAzureGrant$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverrideAzureGrant,
  unknown
> = z.object({
  actions: z.nullable(z.array(z.string())).optional(),
  dataActions: z.nullable(z.array(z.string())).optional(),
  permissions: z.nullable(z.array(z.string())).optional(),
  predefinedRoles: z.nullable(z.array(z.string())).optional(),
  residualPermissions: z.nullable(z.array(z.string())).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackOverrideAzure$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverrideAzure,
  unknown
> = z.object({
  binding: z.lazy(() =>
    DeploymentPreparedStackOverrideAzureBinding$inboundSchema
  ),
  description: z.nullable(z.string()).optional(),
  grant: z.lazy(() => DeploymentPreparedStackOverrideAzureGrant$inboundSchema),
  label: z.nullable(z.string()).optional(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPreparedStackOverrideGcpResource$inboundSchema:
  z.ZodType<DeploymentPreparedStackOverrideGcpResource, unknown> = z.object({
    condition: z.nullable(
      z.union([
        z.lazy(() =>
          DeploymentPreparedStackOverrideConditionResource$inboundSchema
        ),
        z.any(),
      ]),
    ).optional(),
    scope: z.string(),
  });

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

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

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

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

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

/** @internal */
export const DeploymentPreparedStackOverrideGcpStack$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverrideGcpStack,
  unknown
> = z.object({
  condition: z.nullable(
    z.union([
      z.lazy(() => DeploymentPreparedStackOverrideConditionStack$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  scope: z.string(),
});

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

/** @internal */
export const DeploymentPreparedStackOverrideGcpBinding$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverrideGcpBinding,
  unknown
> = z.object({
  resource: z.lazy(() =>
    DeploymentPreparedStackOverrideGcpResource$inboundSchema
  ).optional(),
  stack: z.lazy(() => DeploymentPreparedStackOverrideGcpStack$inboundSchema)
    .optional(),
});

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

/** @internal */
export const DeploymentPreparedStackOverrideGcpGrant$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverrideGcpGrant,
  unknown
> = z.object({
  actions: z.nullable(z.array(z.string())).optional(),
  dataActions: z.nullable(z.array(z.string())).optional(),
  permissions: z.nullable(z.array(z.string())).optional(),
  predefinedRoles: z.nullable(z.array(z.string())).optional(),
  residualPermissions: z.nullable(z.array(z.string())).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackOverrideGcp$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverrideGcp,
  unknown
> = z.object({
  binding: z.lazy(() =>
    DeploymentPreparedStackOverrideGcpBinding$inboundSchema
  ),
  description: z.nullable(z.string()).optional(),
  grant: z.lazy(() => DeploymentPreparedStackOverrideGcpGrant$inboundSchema),
  label: z.nullable(z.string()).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackOverridePlatforms$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverridePlatforms,
  unknown
> = z.object({
  aws: z.nullable(
    z.array(z.lazy(() => DeploymentPreparedStackOverrideAw$inboundSchema)),
  ).optional(),
  azure: z.nullable(
    z.array(z.lazy(() => DeploymentPreparedStackOverrideAzure$inboundSchema)),
  ).optional(),
  gcp: z.nullable(
    z.array(z.lazy(() => DeploymentPreparedStackOverrideGcp$inboundSchema)),
  ).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackOverride$inboundSchema: z.ZodType<
  DeploymentPreparedStackOverride,
  unknown
> = z.object({
  description: z.string(),
  id: z.string(),
  platforms: z.lazy(() =>
    DeploymentPreparedStackOverridePlatforms$inboundSchema
  ),
});

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

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

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

/** @internal */
export const DeploymentPreparedStackManagement2$inboundSchema: z.ZodType<
  DeploymentPreparedStackManagement2,
  unknown
> = z.object({
  override: z.record(
    z.string(),
    z.array(z.union([
      z.lazy(() => DeploymentPreparedStackOverride$inboundSchema),
      z.string(),
    ])),
  ),
});

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

/** @internal */
export const DeploymentPreparedStackExtendAwResource$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendAwResource,
  unknown
> = z.object({
  condition: z.nullable(z.record(z.string(), z.record(z.string(), z.string())))
    .optional(),
  resources: z.array(z.string()),
});

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

/** @internal */
export const DeploymentPreparedStackExtendAwStack$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendAwStack,
  unknown
> = z.object({
  condition: z.nullable(z.record(z.string(), z.record(z.string(), z.string())))
    .optional(),
  resources: z.array(z.string()),
});

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

/** @internal */
export const DeploymentPreparedStackExtendAwBinding$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendAwBinding,
  unknown
> = z.object({
  resource: z.lazy(() => DeploymentPreparedStackExtendAwResource$inboundSchema)
    .optional(),
  stack: z.lazy(() => DeploymentPreparedStackExtendAwStack$inboundSchema)
    .optional(),
});

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

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

/** @internal */
export const DeploymentPreparedStackExtendAwGrant$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendAwGrant,
  unknown
> = z.object({
  actions: z.nullable(z.array(z.string())).optional(),
  dataActions: z.nullable(z.array(z.string())).optional(),
  permissions: z.nullable(z.array(z.string())).optional(),
  predefinedRoles: z.nullable(z.array(z.string())).optional(),
  residualPermissions: z.nullable(z.array(z.string())).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackExtendAw$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendAw,
  unknown
> = z.object({
  binding: z.lazy(() => DeploymentPreparedStackExtendAwBinding$inboundSchema),
  description: z.nullable(z.string()).optional(),
  effect: DeploymentPreparedStackExtendEffect$inboundSchema.optional(),
  grant: z.lazy(() => DeploymentPreparedStackExtendAwGrant$inboundSchema),
  label: z.nullable(z.string()).optional(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPreparedStackExtendAzureBinding$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendAzureBinding,
  unknown
> = z.object({
  resource: z.lazy(() =>
    DeploymentPreparedStackExtendAzureResource$inboundSchema
  ).optional(),
  stack: z.lazy(() => DeploymentPreparedStackExtendAzureStack$inboundSchema)
    .optional(),
});

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

/** @internal */
export const DeploymentPreparedStackExtendAzureGrant$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendAzureGrant,
  unknown
> = z.object({
  actions: z.nullable(z.array(z.string())).optional(),
  dataActions: z.nullable(z.array(z.string())).optional(),
  permissions: z.nullable(z.array(z.string())).optional(),
  predefinedRoles: z.nullable(z.array(z.string())).optional(),
  residualPermissions: z.nullable(z.array(z.string())).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackExtendAzure$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendAzure,
  unknown
> = z.object({
  binding: z.lazy(() =>
    DeploymentPreparedStackExtendAzureBinding$inboundSchema
  ),
  description: z.nullable(z.string()).optional(),
  grant: z.lazy(() => DeploymentPreparedStackExtendAzureGrant$inboundSchema),
  label: z.nullable(z.string()).optional(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPreparedStackExtendGcpResource$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendGcpResource,
  unknown
> = z.object({
  condition: z.nullable(
    z.union([
      z.lazy(() =>
        DeploymentPreparedStackExtendConditionResource$inboundSchema
      ),
      z.any(),
    ]),
  ).optional(),
  scope: z.string(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPreparedStackExtendGcpStack$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendGcpStack,
  unknown
> = z.object({
  condition: z.nullable(
    z.union([
      z.lazy(() => DeploymentPreparedStackExtendConditionStack$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  scope: z.string(),
});

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

/** @internal */
export const DeploymentPreparedStackExtendGcpBinding$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendGcpBinding,
  unknown
> = z.object({
  resource: z.lazy(() => DeploymentPreparedStackExtendGcpResource$inboundSchema)
    .optional(),
  stack: z.lazy(() => DeploymentPreparedStackExtendGcpStack$inboundSchema)
    .optional(),
});

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

/** @internal */
export const DeploymentPreparedStackExtendGcpGrant$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendGcpGrant,
  unknown
> = z.object({
  actions: z.nullable(z.array(z.string())).optional(),
  dataActions: z.nullable(z.array(z.string())).optional(),
  permissions: z.nullable(z.array(z.string())).optional(),
  predefinedRoles: z.nullable(z.array(z.string())).optional(),
  residualPermissions: z.nullable(z.array(z.string())).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackExtendGcp$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendGcp,
  unknown
> = z.object({
  binding: z.lazy(() => DeploymentPreparedStackExtendGcpBinding$inboundSchema),
  description: z.nullable(z.string()).optional(),
  grant: z.lazy(() => DeploymentPreparedStackExtendGcpGrant$inboundSchema),
  label: z.nullable(z.string()).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackExtendPlatforms$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtendPlatforms,
  unknown
> = z.object({
  aws: z.nullable(
    z.array(z.lazy(() => DeploymentPreparedStackExtendAw$inboundSchema)),
  ).optional(),
  azure: z.nullable(
    z.array(z.lazy(() => DeploymentPreparedStackExtendAzure$inboundSchema)),
  ).optional(),
  gcp: z.nullable(
    z.array(z.lazy(() => DeploymentPreparedStackExtendGcp$inboundSchema)),
  ).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackExtend$inboundSchema: z.ZodType<
  DeploymentPreparedStackExtend,
  unknown
> = z.object({
  description: z.string(),
  id: z.string(),
  platforms: z.lazy(() => DeploymentPreparedStackExtendPlatforms$inboundSchema),
});

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

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

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

/** @internal */
export const DeploymentPreparedStackManagement1$inboundSchema: z.ZodType<
  DeploymentPreparedStackManagement1,
  unknown
> = z.object({
  extend: z.record(
    z.string(),
    z.array(z.union([
      z.lazy(() => DeploymentPreparedStackExtend$inboundSchema),
      z.string(),
    ])),
  ),
});

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

/** @internal */
export const DeploymentPreparedStackManagementUnion$inboundSchema: z.ZodType<
  DeploymentPreparedStackManagementUnion,
  unknown
> = z.union([
  z.lazy(() => DeploymentPreparedStackManagement1$inboundSchema),
  z.lazy(() => DeploymentPreparedStackManagement2$inboundSchema),
  DeploymentPreparedStackManagementEnum$inboundSchema,
]);

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

/** @internal */
export const DeploymentPreparedStackProfileAwResource$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileAwResource,
  unknown
> = z.object({
  condition: z.nullable(z.record(z.string(), z.record(z.string(), z.string())))
    .optional(),
  resources: z.array(z.string()),
});

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

/** @internal */
export const DeploymentPreparedStackProfileAwStack$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileAwStack,
  unknown
> = z.object({
  condition: z.nullable(z.record(z.string(), z.record(z.string(), z.string())))
    .optional(),
  resources: z.array(z.string()),
});

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

/** @internal */
export const DeploymentPreparedStackProfileAwBinding$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileAwBinding,
  unknown
> = z.object({
  resource: z.lazy(() => DeploymentPreparedStackProfileAwResource$inboundSchema)
    .optional(),
  stack: z.lazy(() => DeploymentPreparedStackProfileAwStack$inboundSchema)
    .optional(),
});

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

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

/** @internal */
export const DeploymentPreparedStackProfileAwGrant$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileAwGrant,
  unknown
> = z.object({
  actions: z.nullable(z.array(z.string())).optional(),
  dataActions: z.nullable(z.array(z.string())).optional(),
  permissions: z.nullable(z.array(z.string())).optional(),
  predefinedRoles: z.nullable(z.array(z.string())).optional(),
  residualPermissions: z.nullable(z.array(z.string())).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackProfileAw$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileAw,
  unknown
> = z.object({
  binding: z.lazy(() => DeploymentPreparedStackProfileAwBinding$inboundSchema),
  description: z.nullable(z.string()).optional(),
  effect: DeploymentPreparedStackProfileEffect$inboundSchema.optional(),
  grant: z.lazy(() => DeploymentPreparedStackProfileAwGrant$inboundSchema),
  label: z.nullable(z.string()).optional(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPreparedStackProfileAzureBinding$inboundSchema:
  z.ZodType<DeploymentPreparedStackProfileAzureBinding, unknown> = z.object({
    resource: z.lazy(() =>
      DeploymentPreparedStackProfileAzureResource$inboundSchema
    ).optional(),
    stack: z.lazy(() => DeploymentPreparedStackProfileAzureStack$inboundSchema)
      .optional(),
  });

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

/** @internal */
export const DeploymentPreparedStackProfileAzureGrant$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileAzureGrant,
  unknown
> = z.object({
  actions: z.nullable(z.array(z.string())).optional(),
  dataActions: z.nullable(z.array(z.string())).optional(),
  permissions: z.nullable(z.array(z.string())).optional(),
  predefinedRoles: z.nullable(z.array(z.string())).optional(),
  residualPermissions: z.nullable(z.array(z.string())).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackProfileAzure$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileAzure,
  unknown
> = z.object({
  binding: z.lazy(() =>
    DeploymentPreparedStackProfileAzureBinding$inboundSchema
  ),
  description: z.nullable(z.string()).optional(),
  grant: z.lazy(() => DeploymentPreparedStackProfileAzureGrant$inboundSchema),
  label: z.nullable(z.string()).optional(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPreparedStackProfileGcpResource$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileGcpResource,
  unknown
> = z.object({
  condition: z.nullable(
    z.union([
      z.lazy(() =>
        DeploymentPreparedStackProfileConditionResource$inboundSchema
      ),
      z.any(),
    ]),
  ).optional(),
  scope: z.string(),
});

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

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

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

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

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

/** @internal */
export const DeploymentPreparedStackProfileGcpStack$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileGcpStack,
  unknown
> = z.object({
  condition: z.nullable(
    z.union([
      z.lazy(() => DeploymentPreparedStackProfileConditionStack$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  scope: z.string(),
});

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

/** @internal */
export const DeploymentPreparedStackProfileGcpBinding$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileGcpBinding,
  unknown
> = z.object({
  resource: z.lazy(() =>
    DeploymentPreparedStackProfileGcpResource$inboundSchema
  ).optional(),
  stack: z.lazy(() => DeploymentPreparedStackProfileGcpStack$inboundSchema)
    .optional(),
});

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

/** @internal */
export const DeploymentPreparedStackProfileGcpGrant$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileGcpGrant,
  unknown
> = z.object({
  actions: z.nullable(z.array(z.string())).optional(),
  dataActions: z.nullable(z.array(z.string())).optional(),
  permissions: z.nullable(z.array(z.string())).optional(),
  predefinedRoles: z.nullable(z.array(z.string())).optional(),
  residualPermissions: z.nullable(z.array(z.string())).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackProfileGcp$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfileGcp,
  unknown
> = z.object({
  binding: z.lazy(() => DeploymentPreparedStackProfileGcpBinding$inboundSchema),
  description: z.nullable(z.string()).optional(),
  grant: z.lazy(() => DeploymentPreparedStackProfileGcpGrant$inboundSchema),
  label: z.nullable(z.string()).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackProfilePlatforms$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfilePlatforms,
  unknown
> = z.object({
  aws: z.nullable(
    z.array(z.lazy(() => DeploymentPreparedStackProfileAw$inboundSchema)),
  ).optional(),
  azure: z.nullable(
    z.array(z.lazy(() => DeploymentPreparedStackProfileAzure$inboundSchema)),
  ).optional(),
  gcp: z.nullable(
    z.array(z.lazy(() => DeploymentPreparedStackProfileGcp$inboundSchema)),
  ).optional(),
});

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

/** @internal */
export const DeploymentPreparedStackProfile$inboundSchema: z.ZodType<
  DeploymentPreparedStackProfile,
  unknown
> = z.object({
  description: z.string(),
  id: z.string(),
  platforms: z.lazy(() =>
    DeploymentPreparedStackProfilePlatforms$inboundSchema
  ),
});

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

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

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

/** @internal */
export const DeploymentPreparedStackPermissions$inboundSchema: z.ZodType<
  DeploymentPreparedStackPermissions,
  unknown
> = z.object({
  management: z.union([
    z.lazy(() => DeploymentPreparedStackManagement1$inboundSchema),
    z.lazy(() => DeploymentPreparedStackManagement2$inboundSchema),
    DeploymentPreparedStackManagementEnum$inboundSchema,
  ]).optional(),
  profiles: z.record(
    z.string(),
    z.record(
      z.string(),
      z.array(
        z.union([
          z.lazy(() => DeploymentPreparedStackProfile$inboundSchema),
          z.string(),
        ]),
      ),
    ),
  ),
});

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

/** @internal */
export const DeploymentPreparedStackConfig$inboundSchema: z.ZodType<
  DeploymentPreparedStackConfig,
  unknown
> = collectExtraKeys$(
  z.object({
    id: z.string(),
    type: z.string(),
  }).catchall(z.any()),
  "additionalProperties",
  true,
);

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

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

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

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

/** @internal */
export const DeploymentPreparedStackResources$inboundSchema: z.ZodType<
  DeploymentPreparedStackResources,
  unknown
> = z.object({
  config: z.lazy(() => DeploymentPreparedStackConfig$inboundSchema),
  dependencies: z.array(
    z.lazy(() => DeploymentPreparedStackDependency$inboundSchema),
  ),
  enabledWhen: z.nullable(z.string()).optional(),
  lifecycle: DeploymentPreparedStackLifecycle$inboundSchema,
  remoteAccess: z.boolean().optional(),
});

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

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

/** @internal */
export const DeploymentPreparedStack$inboundSchema: z.ZodType<
  DeploymentPreparedStack,
  unknown
> = z.object({
  id: z.string(),
  inputs: z.array(z.lazy(() => DeploymentPreparedStackInput$inboundSchema))
    .optional(),
  permissions: z.lazy(() => DeploymentPreparedStackPermissions$inboundSchema)
    .optional(),
  resources: z.record(
    z.string(),
    z.lazy(() => DeploymentPreparedStackResources$inboundSchema),
  ),
  supportedPlatforms: z.nullable(
    z.array(DeploymentPreparedStackSupportedPlatform$inboundSchema),
  ).optional(),
});

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

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

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

/** @internal */
export const DeploymentSetupUpdateAuthorization$inboundSchema: z.ZodType<
  DeploymentSetupUpdateAuthorization,
  unknown
> = z.object({
  baselineFrozenDigest: z.string(),
  nonce: z.string(),
  releaseId: z.string(),
  setupFingerprint: z.string(),
  setupFingerprintVersion: z.int(),
  setupTarget: z.string(),
  targetFrozenDigest: z.string(),
});

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

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

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

/** @internal */
export const DeploymentRuntimeMetadata$inboundSchema: z.ZodType<
  DeploymentRuntimeMetadata,
  unknown
> = z.object({
  directSetupRevision: z.nullable(z.string()).optional(),
  initialSetupAuthority: DeploymentInitialSetupAuthority$inboundSchema
    .optional(),
  lastSyncedEnvVarsHash: z.nullable(z.string()).optional(),
  lastSyncedSecretNames: z.array(z.string()).optional(),
  pendingPreparedStack: z.nullable(
    z.union([
      z.lazy(() => DeploymentPendingPreparedStack$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  persistedGateAnswers: z.record(z.string(), z.boolean()).optional(),
  preparedStack: z.nullable(
    z.union([z.lazy(() => DeploymentPreparedStack$inboundSchema), z.any()]),
  ).optional(),
  registryAccessGranted: z.boolean().optional(),
  setupUpdateAuthorization: z.nullable(
    z.union([
      z.lazy(() => DeploymentSetupUpdateAuthorization$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

/** @internal */
export const DeploymentError$inboundSchema: z.ZodType<
  DeploymentError,
  unknown
> = z.object({
  code: z.string(),
  context: z.nullable(z.any()).optional(),
  hint: z.nullable(z.string()).optional(),
  httpStatusCode: z.nullable(z.int()).optional(),
  internal: z.boolean(),
  message: z.string(),
  retryable: z.boolean().default(false),
  source: z.nullable(z.any()).optional(),
});

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

/** @internal */
export const DeploymentUpdateState$inboundSchema: z.ZodType<
  DeploymentUpdateState,
  unknown
> = z.object({
  active: z.nullable(DeploymentUpdateOperationSummary$inboundSchema),
  next: z.nullable(DeploymentUpdateOperationSummary$inboundSchema),
  latest: z.nullable(DeploymentUpdateOperationSummary$inboundSchema),
});

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

/** @internal */
export const Deployment$inboundSchema: z.ZodType<Deployment, unknown> = z
  .object({
    id: z.string(),
    name: z.string(),
    publicSubdomain: z.nullable(z.string()).optional(),
    status: DeploymentStatus$inboundSchema,
    projectId: z.string(),
    platform: DeploymentPlatform$inboundSchema,
    basePlatform: z.nullable(DeploymentBasePlatform$inboundSchema).optional(),
    region: z.nullable(z.string()).optional(),
    deploymentProtocolVersion: z.int(),
    deploymentGroupId: z.string(),
    purpose: DeploymentPurpose$inboundSchema,
    environmentInfo: z.nullable(
      z.union([
        z.lazy(() => DeploymentEnvironmentInfoGcp$inboundSchema),
        z.lazy(() => DeploymentEnvironmentInfoAzure$inboundSchema),
        z.lazy(() => DeploymentEnvironmentInfoLocal$inboundSchema),
        z.lazy(() => DeploymentEnvironmentInfoAws$inboundSchema),
        z.lazy(() => DeploymentEnvironmentInfoTest$inboundSchema),
        z.any(),
      ]),
    ).optional(),
    stackSettings: z.lazy(() => DeploymentStackSettings$inboundSchema),
    stackState: z.nullable(z.lazy(() => DeploymentStackState$inboundSchema))
      .optional(),
    runtimeMetadata: z.nullable(
      z.lazy(() => DeploymentRuntimeMetadata$inboundSchema),
    ).optional(),
    currentReleaseId: z.nullable(z.string()).optional(),
    desiredReleaseId: z.nullable(z.string()).optional(),
    pinnedReleaseId: z.nullable(z.string()).optional(),
    releaseChannel: z.string(),
    importSource: z.nullable(DeploymentImportSource$inboundSchema).optional(),
    setupMethod: z.nullable(DeploymentSetupMethod1$inboundSchema).optional(),
    setupMetadata: z.nullable(z.record(z.string(), z.nullable(z.any())))
      .optional(),
    setupTarget: z.nullable(z.string()).optional(),
    setupFingerprint: z.nullable(z.string()).optional(),
    setupFingerprintVersion: z.nullable(z.int()).optional(),
    operatorScope: z.nullable(z.string()).optional(),
    operatorPermission: z.nullable(z.string()).optional(),
    operatorVersion: z.nullable(z.string()).optional(),
    capabilities: z.nullable(z.array(OperatorCapabilityReport$inboundSchema))
      .optional(),
    observedOperationsBundleHash: z.nullable(z.string()).optional(),
    observedOperations: z.nullable(z.array(ReportedOperation$inboundSchema))
      .optional(),
    retryRequested: z.boolean(),
    lastHeartbeatAt: z.nullable(
      z.iso.datetime({ offset: true }).transform(v => new Date(v)),
    ).optional(),
    error: z.nullable(z.lazy(() => DeploymentError$inboundSchema)).optional(),
    updateState: z.lazy(() => DeploymentUpdateState$inboundSchema).optional(),
    createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
    updatedAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
    managerId: z.string(),
    workspaceId: z.string(),
  });

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