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

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 {
  EnvironmentVariableConfig,
  EnvironmentVariableConfig$inboundSchema,
} from "./environmentvariableconfig.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 SyncListResponseStatus = {
  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 SyncListResponseStatus = ClosedEnum<typeof SyncListResponseStatus>;

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

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

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

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

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

/**
 * Local platform environment information
 */
export type SyncListResponseEnvironmentInfoLocal = {
  /**
   * 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: SyncListResponsePlatformLocal;
};

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

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

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

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

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

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

/**
 * Cloud environment information
 */
export type SyncListResponseEnvironmentInfoUnion =
  | SyncListResponseEnvironmentInfoGcp
  | SyncListResponseEnvironmentInfoAzure
  | SyncListResponseEnvironmentInfoLocal
  | SyncListResponseEnvironmentInfoAws
  | SyncListResponseEnvironmentInfoTest
  | any;

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

export type SyncListResponsePoolsAutoscale = {
  failureDomains?: SyncListResponseFailureDomains2 | 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 SyncListResponseFailureDomains1 = {
  /**
   * 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 SyncListResponseFailureDomainsUnion1 =
  | SyncListResponseFailureDomains1
  | any;

export type SyncListResponsePoolsFixed = {
  failureDomains?: SyncListResponseFailureDomains1 | 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 SyncListResponsePoolsUnion =
  | SyncListResponsePoolsFixed
  | SyncListResponsePoolsAutoscale;

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

export type SyncListResponseComputeUnion = SyncListResponseCompute | any;

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

export type SyncListResponseAws = {
  certificateArn: string;
};

export type SyncListResponseAwsUnion = SyncListResponseAws | any;

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

export type SyncListResponseAzureUnion =
  | SyncListResponseAzureStackSettings
  | any;

export type SyncListResponseGcpStackSettings = {
  certificateName: string;
};

export type SyncListResponseGcpUnion = SyncListResponseGcpStackSettings | any;

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

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

export type SyncListResponseDomainsKubernetesUnion =
  | SyncListResponseDomainsKubernetes
  | any;

/**
 * Platform-specific certificate references for custom domains.
 */
export type SyncListResponseDomainsCertificate = {
  aws?: SyncListResponseAws | any | null | undefined;
  azure?: SyncListResponseAzureStackSettings | any | null | undefined;
  gcp?: SyncListResponseGcpStackSettings | any | null | undefined;
  kubernetes?: SyncListResponseDomainsKubernetes | any | null | undefined;
};

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

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

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

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

export type SyncListResponsePublicEndpointTargetMachineAddresses = {
  mode: SyncListResponseModeMachineAddresses;
};

export type SyncListResponsePublicEndpointTargetUnion =
  | SyncListResponsePublicEndpointTargetLoadBalancer
  | SyncListResponsePublicEndpointTargetMachineAddresses
  | 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 SyncListResponseDomains = {
  /**
   * Custom domain configuration per resource ID.
   */
  customDomains?:
    | { [k: string]: SyncListResponseCustomDomains }
    | null
    | undefined;
  publicEndpointTarget?:
    | SyncListResponsePublicEndpointTargetLoadBalancer
    | SyncListResponsePublicEndpointTargetMachineAddresses
    | any
    | null
    | undefined;
};

export type SyncListResponseDomainsUnion = SyncListResponseDomains | 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 SyncListResponseExternalBindings = {};

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

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

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

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

export type SyncListResponseClusterUnion = SyncListResponseCluster | any;

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

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

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

export type SyncListResponseCertificateManagedAcmImport2 = {
  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 SyncListResponseCertificateTLSSecretRef2 = {
  /**
   * 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 SyncListResponseCertificateUnion2 =
  | SyncListResponseCertificateTLSSecretRef2
  | SyncListResponseCertificateManagedAcmImport2
  | SyncListResponseCertificateAwsAcmArn2
  | SyncListResponseCertificateManagedTLSSecret2
  | SyncListResponseCertificateNone2;

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

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

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

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

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

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

export type SyncListResponseProviderAwsAlb4 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: SyncListResponseProviderAwsAlbEnum4;
  /**
   * 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 SyncListResponseProviderUnion4 =
  | SyncListResponseProviderAwsAlb4
  | SyncListResponseProviderAzureApplicationGatewayForContainers4
  | SyncListResponseProviderGkeGateway4
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type SyncListResponseRouteGateway2 = {
  /**
   * 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?:
    | SyncListResponseProviderAwsAlb4
    | SyncListResponseProviderAzureApplicationGatewayForContainers4
    | SyncListResponseProviderGkeGateway4
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type SyncListResponseProviderAwsAlb3 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: SyncListResponseProviderAwsAlbEnum3;
  /**
   * 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 SyncListResponseProviderUnion3 =
  | SyncListResponseProviderAwsAlb3
  | SyncListResponseProviderAzureApplicationGatewayForContainers3
  | SyncListResponseProviderGkeGateway3
  | any;

/**
 * Shared Ingress route profile values.
 */
export type SyncListResponseRouteIngress2 = {
  /**
   * 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?:
    | SyncListResponseProviderAwsAlb3
    | SyncListResponseProviderAzureApplicationGatewayForContainers3
    | SyncListResponseProviderGkeGateway3
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type SyncListResponseRouteUnion2 =
  | SyncListResponseRouteIngress2
  | SyncListResponseRouteGateway2;

export type SyncListResponseExposureCustom = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | SyncListResponseCertificateTLSSecretRef2
    | SyncListResponseCertificateManagedAcmImport2
    | SyncListResponseCertificateAwsAcmArn2
    | SyncListResponseCertificateManagedTLSSecret2
    | SyncListResponseCertificateNone2;
  /**
   * Hostname routed by the Kubernetes public endpoint.
   */
  domain: string;
  mode: SyncListResponseModeCustom;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: SyncListResponseRouteIngress2 | SyncListResponseRouteGateway2;
};

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

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

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

export type SyncListResponseCertificateManagedAcmImport1 = {
  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 SyncListResponseCertificateTLSSecretRef1 = {
  /**
   * 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 SyncListResponseCertificateUnion1 =
  | SyncListResponseCertificateTLSSecretRef1
  | SyncListResponseCertificateManagedAcmImport1
  | SyncListResponseCertificateAwsAcmArn1
  | SyncListResponseCertificateManagedTLSSecret1
  | SyncListResponseCertificateNone1;

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

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

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

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

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

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

export type SyncListResponseProviderAwsAlb2 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: SyncListResponseProviderAwsAlbEnum2;
  /**
   * 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 SyncListResponseProviderUnion2 =
  | SyncListResponseProviderAwsAlb2
  | SyncListResponseProviderAzureApplicationGatewayForContainers2
  | SyncListResponseProviderGkeGateway2
  | any;

/**
 * Shared Gateway API route profile values.
 */
export type SyncListResponseRouteGateway1 = {
  /**
   * 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?:
    | SyncListResponseProviderAwsAlb2
    | SyncListResponseProviderAzureApplicationGatewayForContainers2
    | SyncListResponseProviderGkeGateway2
    | any
    | null
    | undefined;
  routeApi: "gateway";
};

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

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

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

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

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

export type SyncListResponseProviderAwsAlb1 = {
  /**
   * Optional ALB IP address type, such as `dualstack`.
   */
  ipAddressType?: string | null | undefined;
  provider: SyncListResponseProviderAwsAlbEnum1;
  /**
   * 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 SyncListResponseProviderUnion1 =
  | SyncListResponseProviderAwsAlb1
  | SyncListResponseProviderAzureApplicationGatewayForContainers1
  | SyncListResponseProviderGkeGateway1
  | any;

/**
 * Shared Ingress route profile values.
 */
export type SyncListResponseRouteIngress1 = {
  /**
   * 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?:
    | SyncListResponseProviderAwsAlb1
    | SyncListResponseProviderAzureApplicationGatewayForContainers1
    | SyncListResponseProviderGkeGateway1
    | any
    | null
    | undefined;
  routeApi: "ingress";
};

/**
 * Kubernetes route API selected for public endpoints.
 */
export type SyncListResponseRouteUnion1 =
  | SyncListResponseRouteIngress1
  | SyncListResponseRouteGateway1;

export type SyncListResponseExposureGenerated = {
  /**
   * Certificate publication or reference mode for Kubernetes public endpoints.
   */
  certificate:
    | SyncListResponseCertificateTLSSecretRef1
    | SyncListResponseCertificateManagedAcmImport1
    | SyncListResponseCertificateAwsAcmArn1
    | SyncListResponseCertificateManagedTLSSecret1
    | SyncListResponseCertificateNone1;
  mode: SyncListResponseModeGenerated;
  /**
   * Kubernetes route API selected for public endpoints.
   */
  route: SyncListResponseRouteIngress1 | SyncListResponseRouteGateway1;
};

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

export type SyncListResponseExposureDisabled = {
  mode: SyncListResponseModeDisabled;
};

export type SyncListResponseExposureUnion =
  | SyncListResponseExposureCustom
  | SyncListResponseExposureGenerated
  | SyncListResponseExposureDisabled
  | 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 SyncListResponseKubernetes = {
  cluster?: SyncListResponseCluster | any | null | undefined;
  exposure?:
    | SyncListResponseExposureCustom
    | SyncListResponseExposureGenerated
    | SyncListResponseExposureDisabled
    | any
    | null
    | undefined;
};

export type SyncListResponseKubernetesUnion = SyncListResponseKubernetes | any;

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

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

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

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

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

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

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

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

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

export type SyncListResponseNetworkUseDefault = {
  type: SyncListResponseTypeUseDefault;
};

export type SyncListResponseNetworkUnion =
  | SyncListResponseNetworkByoVpcAws
  | SyncListResponseNetworkByoVpcGcp
  | SyncListResponseNetworkByoVnetAzure
  | SyncListResponseNetworkUseDefault
  | SyncListResponseNetworkCreate
  | any;

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

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

/**
 * User-provided configuration (network, deployment model, approvals)
 */
export type SyncListResponseStackSettings = {
  compute?: SyncListResponseCompute | any | null | undefined;
  /**
   * Deployment model: how updates are delivered to the remote environment.
   */
  deploymentModel?: SyncListResponseDeploymentModel | undefined;
  domains?: SyncListResponseDomains | 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?: SyncListResponseExternalBindings | null | undefined;
  /**
   * How heartbeat health checks are handled.
   */
  heartbeats?: SyncListResponseHeartbeats | undefined;
  kubernetes?: SyncListResponseKubernetes | any | null | undefined;
  network?:
    | SyncListResponseNetworkByoVpcAws
    | SyncListResponseNetworkByoVpcGcp
    | SyncListResponseNetworkByoVnetAzure
    | SyncListResponseNetworkUseDefault
    | SyncListResponseNetworkCreate
    | 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?: SyncListResponseTelemetry | undefined;
  /**
   * How updates are delivered to the deployment.
   */
  updates?: SyncListResponseUpdates | undefined;
};

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

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

export type SyncListResponseControllerPlatformUnion =
  | SyncListResponseControllerPlatformEnum
  | any;

/**
 * Reference to a resource by its stable id and resource type.
 */
export type SyncListResponseStackStateDependency = {
  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 SyncListResponseErrorStackState = {
  /**
   * 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 SyncListResponseErrorUnion = SyncListResponseErrorStackState | any;

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

export type SyncListResponseLifecycleUnion =
  | SyncListResponseLifecycleStackStateEnum
  | 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 SyncListResponseOutputs = {
  /**
   * 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 SyncListResponseOutputsUnion = SyncListResponseOutputs | 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 SyncListResponsePreviousConfig = {
  /**
   * 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 SyncListResponsePreviousConfigUnion =
  | SyncListResponsePreviousConfig
  | any;

/**
 * Represents the high-level status of a resource during its lifecycle.
 */
export const SyncListResponseStackStateStatus = {
  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 SyncListResponseStackStateStatus = ClosedEnum<
  typeof SyncListResponseStackStateStatus
>;

/**
 * Represents the state of a single resource within the stack for a specific platform.
 */
export type SyncListResponseStackStateResources = {
  /**
   * 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: SyncListResponseStackStateConfig;
  controllerPlatform?:
    | SyncListResponseControllerPlatformEnum
    | 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<SyncListResponseStackStateDependency> | undefined;
  error?: SyncListResponseErrorStackState | 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?: SyncListResponseLifecycleStackStateEnum | any | null | undefined;
  outputs?: SyncListResponseOutputs | any | null | undefined;
  previousConfig?: SyncListResponsePreviousConfig | 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: SyncListResponseStackStateStatus;
  /**
   * 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 SyncListResponseStackState = {
  /**
   * Represents the target cloud platform.
   */
  platform: SyncListResponseStackStatePlatform;
  /**
   * 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]: SyncListResponseStackStateResources };
};

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

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

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

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

export type SyncListResponsePendingPreparedStackDefaultBoolean = {
  type: SyncListResponsePendingPreparedStackTypeBoolean;
  /**
   * Boolean default.
   */
  value: boolean;
};

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

export type SyncListResponsePendingPreparedStackDefaultNumber = {
  type: SyncListResponsePendingPreparedStackTypeNumber;
  /**
   * Number default.
   */
  value: string;
};

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

export type SyncListResponsePendingPreparedStackDefaultString = {
  type: SyncListResponsePendingPreparedStackTypeString;
  /**
   * String default.
   */
  value: string;
};

export type SyncListResponsePendingPreparedStackDefaultUnion =
  | SyncListResponsePendingPreparedStackDefaultString
  | SyncListResponsePendingPreparedStackDefaultNumber
  | SyncListResponsePendingPreparedStackDefaultBoolean
  | SyncListResponsePendingPreparedStackDefaultStringList
  | any;

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

export type SyncListResponsePendingPreparedStackTypeUnion =
  | SyncListResponsePendingPreparedStackTypeEnvEnum
  | any;

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

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

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

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

/**
 * Portable stack input validation constraints.
 */
export type SyncListResponsePendingPreparedStackValidation = {
  /**
   * 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 SyncListResponsePendingPreparedStackValidationUnion =
  | SyncListResponsePendingPreparedStackValidation
  | any;

/**
 * Stack input definition serialized into a release stack.
 */
export type SyncListResponsePendingPreparedStackInput = {
  default?:
    | SyncListResponsePendingPreparedStackDefaultString
    | SyncListResponsePendingPreparedStackDefaultNumber
    | SyncListResponsePendingPreparedStackDefaultBoolean
    | SyncListResponsePendingPreparedStackDefaultStringList
    | any
    | null
    | undefined;
  /**
   * Human-facing helper text.
   */
  description: string;
  /**
   * Runtime env-var mappings for v1 input resolution.
   */
  env?: Array<SyncListResponsePendingPreparedStackEnv> | undefined;
  /**
   * Stable input ID used by CLI/API calls.
   */
  id: string;
  /**
   * Primitive stack input kind.
   */
  kind: SyncListResponsePendingPreparedStackKind;
  /**
   * Human-facing field label.
   */
  label: string;
  /**
   * Example placeholder shown in UI.
   */
  placeholder?: string | null | undefined;
  /**
   * Platforms where this input applies.
   */
  platforms?:
    | Array<SyncListResponsePendingPreparedStackPlatform>
    | null
    | undefined;
  /**
   * Who can provide this value.
   */
  providedBy: Array<SyncListResponsePendingPreparedStackProvidedBy>;
  /**
   * Whether a resolved value is required before deployment can proceed.
   */
  required: boolean;
  validation?:
    | SyncListResponsePendingPreparedStackValidation
    | any
    | null
    | undefined;
};

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

/**
 * AWS-specific binding specification
 */
export type SyncListResponsePendingPreparedStackOverrideAwResource = {
  /**
   * 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 SyncListResponsePendingPreparedStackOverrideAwStack = {
  /**
   * 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 SyncListResponsePendingPreparedStackOverrideAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: SyncListResponsePendingPreparedStackOverrideAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: SyncListResponsePendingPreparedStackOverrideAwStack | undefined;
};

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

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackOverrideAwGrant = {
  /**
   * 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 SyncListResponsePendingPreparedStackOverrideAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePendingPreparedStackOverrideAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: SyncListResponsePendingPreparedStackOverrideEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePendingPreparedStackOverrideAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackOverrideAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?:
    | SyncListResponsePendingPreparedStackOverrideAzureResource
    | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: SyncListResponsePendingPreparedStackOverrideAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackOverrideAzureGrant = {
  /**
   * 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 SyncListResponsePendingPreparedStackOverrideAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePendingPreparedStackOverrideAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePendingPreparedStackOverrideAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

export type SyncListResponsePendingPreparedStackOverrideResourceConditionUnion =
  | SyncListResponsePendingPreparedStackOverrideConditionResource
  | any;

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

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

export type SyncListResponsePendingPreparedStackOverrideStackConditionUnion =
  | SyncListResponsePendingPreparedStackOverrideConditionStack
  | any;

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackOverrideGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?:
    | SyncListResponsePendingPreparedStackOverrideGcpResource
    | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: SyncListResponsePendingPreparedStackOverrideGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackOverrideGcpGrant = {
  /**
   * 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 SyncListResponsePendingPreparedStackOverrideGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePendingPreparedStackOverrideGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePendingPreparedStackOverrideGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePendingPreparedStackOverridePlatforms = {
  /**
   * AWS permission configurations
   */
  aws?:
    | Array<SyncListResponsePendingPreparedStackOverrideAw>
    | null
    | undefined;
  /**
   * Azure permission configurations
   */
  azure?:
    | Array<SyncListResponsePendingPreparedStackOverrideAzure>
    | null
    | undefined;
  /**
   * GCP permission configurations
   */
  gcp?:
    | Array<SyncListResponsePendingPreparedStackOverrideGcp>
    | null
    | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePendingPreparedStackOverride = {
  /**
   * 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: SyncListResponsePendingPreparedStackOverridePlatforms;
};

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

export type SyncListResponsePendingPreparedStackManagement2 = {
  /**
   * 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<SyncListResponsePendingPreparedStackOverride | string>;
  };
};

/**
 * AWS-specific binding specification
 */
export type SyncListResponsePendingPreparedStackExtendAwResource = {
  /**
   * 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 SyncListResponsePendingPreparedStackExtendAwStack = {
  /**
   * 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 SyncListResponsePendingPreparedStackExtendAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: SyncListResponsePendingPreparedStackExtendAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: SyncListResponsePendingPreparedStackExtendAwStack | undefined;
};

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

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackExtendAwGrant = {
  /**
   * 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 SyncListResponsePendingPreparedStackExtendAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePendingPreparedStackExtendAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: SyncListResponsePendingPreparedStackExtendEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePendingPreparedStackExtendAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackExtendAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?:
    | SyncListResponsePendingPreparedStackExtendAzureResource
    | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: SyncListResponsePendingPreparedStackExtendAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackExtendAzureGrant = {
  /**
   * 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 SyncListResponsePendingPreparedStackExtendAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePendingPreparedStackExtendAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePendingPreparedStackExtendAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

export type SyncListResponsePendingPreparedStackExtendResourceConditionUnion =
  | SyncListResponsePendingPreparedStackExtendConditionResource
  | any;

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

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

export type SyncListResponsePendingPreparedStackExtendStackConditionUnion =
  | SyncListResponsePendingPreparedStackExtendConditionStack
  | any;

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackExtendGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?: SyncListResponsePendingPreparedStackExtendGcpResource | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: SyncListResponsePendingPreparedStackExtendGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackExtendGcpGrant = {
  /**
   * 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 SyncListResponsePendingPreparedStackExtendGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePendingPreparedStackExtendGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePendingPreparedStackExtendGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePendingPreparedStackExtendPlatforms = {
  /**
   * AWS permission configurations
   */
  aws?: Array<SyncListResponsePendingPreparedStackExtendAw> | null | undefined;
  /**
   * Azure permission configurations
   */
  azure?:
    | Array<SyncListResponsePendingPreparedStackExtendAzure>
    | null
    | undefined;
  /**
   * GCP permission configurations
   */
  gcp?: Array<SyncListResponsePendingPreparedStackExtendGcp> | null | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePendingPreparedStackExtend = {
  /**
   * 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: SyncListResponsePendingPreparedStackExtendPlatforms;
};

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

export type SyncListResponsePendingPreparedStackManagement1 = {
  /**
   * 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<SyncListResponsePendingPreparedStackExtend | string>;
  };
};

/**
 * Management permissions configuration for stack management access
 */
export type SyncListResponsePendingPreparedStackManagementUnion =
  | SyncListResponsePendingPreparedStackManagement1
  | SyncListResponsePendingPreparedStackManagement2
  | SyncListResponsePendingPreparedStackManagementEnum;

/**
 * AWS-specific binding specification
 */
export type SyncListResponsePendingPreparedStackProfileAwResource = {
  /**
   * 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 SyncListResponsePendingPreparedStackProfileAwStack = {
  /**
   * 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 SyncListResponsePendingPreparedStackProfileAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: SyncListResponsePendingPreparedStackProfileAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: SyncListResponsePendingPreparedStackProfileAwStack | undefined;
};

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

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackProfileAwGrant = {
  /**
   * 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 SyncListResponsePendingPreparedStackProfileAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePendingPreparedStackProfileAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: SyncListResponsePendingPreparedStackProfileEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePendingPreparedStackProfileAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackProfileAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?:
    | SyncListResponsePendingPreparedStackProfileAzureResource
    | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: SyncListResponsePendingPreparedStackProfileAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackProfileAzureGrant = {
  /**
   * 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 SyncListResponsePendingPreparedStackProfileAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePendingPreparedStackProfileAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePendingPreparedStackProfileAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

export type SyncListResponsePendingPreparedStackProfileResourceConditionUnion =
  | SyncListResponsePendingPreparedStackProfileConditionResource
  | any;

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

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

export type SyncListResponsePendingPreparedStackProfileStackConditionUnion =
  | SyncListResponsePendingPreparedStackProfileConditionStack
  | any;

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackProfileGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?: SyncListResponsePendingPreparedStackProfileGcpResource | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: SyncListResponsePendingPreparedStackProfileGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackProfileGcpGrant = {
  /**
   * 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 SyncListResponsePendingPreparedStackProfileGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePendingPreparedStackProfileGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePendingPreparedStackProfileGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePendingPreparedStackProfilePlatforms = {
  /**
   * AWS permission configurations
   */
  aws?: Array<SyncListResponsePendingPreparedStackProfileAw> | null | undefined;
  /**
   * Azure permission configurations
   */
  azure?:
    | Array<SyncListResponsePendingPreparedStackProfileAzure>
    | null
    | undefined;
  /**
   * GCP permission configurations
   */
  gcp?:
    | Array<SyncListResponsePendingPreparedStackProfileGcp>
    | null
    | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePendingPreparedStackProfile = {
  /**
   * 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: SyncListResponsePendingPreparedStackProfilePlatforms;
};

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

/**
 * Combined permissions configuration that contains both profiles and management
 */
export type SyncListResponsePendingPreparedStackPermissions = {
  /**
   * Management permissions configuration for stack management access
   */
  management?:
    | SyncListResponsePendingPreparedStackManagement1
    | SyncListResponsePendingPreparedStackManagement2
    | SyncListResponsePendingPreparedStackManagementEnum
    | 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<SyncListResponsePendingPreparedStackProfile | 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 SyncListResponsePendingPreparedStackConfig = {
  /**
   * 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 SyncListResponsePendingPreparedStackDependency = {
  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 SyncListResponsePendingPreparedStackLifecycle = {
  Frozen: "frozen",
  Live: "live",
} as const;
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export type SyncListResponsePendingPreparedStackLifecycle = ClosedEnum<
  typeof SyncListResponsePendingPreparedStackLifecycle
>;

export type SyncListResponsePendingPreparedStackResources = {
  /**
   * 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: SyncListResponsePendingPreparedStackConfig;
  /**
   * Additional dependencies for this resource beyond those defined in the resource itself.
   *
   * @remarks
   * The total dependencies are: resource.get_dependencies() + this list
   */
  dependencies: Array<SyncListResponsePendingPreparedStackDependency>;
  /**
   * 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: SyncListResponsePendingPreparedStackLifecycle;
  /**
   * 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 SyncListResponsePendingPreparedStackSupportedPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Local: "local",
  Test: "test",
} as const;
/**
 * Represents the target cloud platform.
 */
export type SyncListResponsePendingPreparedStackSupportedPlatform = ClosedEnum<
  typeof SyncListResponsePendingPreparedStackSupportedPlatform
>;

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

export type SyncListResponsePendingPreparedStackUnion =
  | SyncListResponsePendingPreparedStack
  | any;

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

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

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

export type SyncListResponsePreparedStackDefaultBoolean = {
  type: SyncListResponsePreparedStackTypeBoolean;
  /**
   * Boolean default.
   */
  value: boolean;
};

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

export type SyncListResponsePreparedStackDefaultNumber = {
  type: SyncListResponsePreparedStackTypeNumber;
  /**
   * Number default.
   */
  value: string;
};

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

export type SyncListResponsePreparedStackDefaultString = {
  type: SyncListResponsePreparedStackTypeString;
  /**
   * String default.
   */
  value: string;
};

export type SyncListResponsePreparedStackDefaultUnion =
  | SyncListResponsePreparedStackDefaultString
  | SyncListResponsePreparedStackDefaultNumber
  | SyncListResponsePreparedStackDefaultBoolean
  | SyncListResponsePreparedStackDefaultStringList
  | any;

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

export type SyncListResponsePreparedStackTypeUnion =
  | SyncListResponsePreparedStackTypeEnvEnum
  | any;

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

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

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

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

/**
 * Portable stack input validation constraints.
 */
export type SyncListResponsePreparedStackValidation = {
  /**
   * 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 SyncListResponsePreparedStackValidationUnion =
  | SyncListResponsePreparedStackValidation
  | any;

/**
 * Stack input definition serialized into a release stack.
 */
export type SyncListResponsePreparedStackInput = {
  default?:
    | SyncListResponsePreparedStackDefaultString
    | SyncListResponsePreparedStackDefaultNumber
    | SyncListResponsePreparedStackDefaultBoolean
    | SyncListResponsePreparedStackDefaultStringList
    | any
    | null
    | undefined;
  /**
   * Human-facing helper text.
   */
  description: string;
  /**
   * Runtime env-var mappings for v1 input resolution.
   */
  env?: Array<SyncListResponsePreparedStackEnv> | undefined;
  /**
   * Stable input ID used by CLI/API calls.
   */
  id: string;
  /**
   * Primitive stack input kind.
   */
  kind: SyncListResponsePreparedStackKind;
  /**
   * Human-facing field label.
   */
  label: string;
  /**
   * Example placeholder shown in UI.
   */
  placeholder?: string | null | undefined;
  /**
   * Platforms where this input applies.
   */
  platforms?: Array<SyncListResponsePreparedStackPlatform> | null | undefined;
  /**
   * Who can provide this value.
   */
  providedBy: Array<SyncListResponsePreparedStackProvidedBy>;
  /**
   * Whether a resolved value is required before deployment can proceed.
   */
  required: boolean;
  validation?: SyncListResponsePreparedStackValidation | any | null | undefined;
};

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

/**
 * AWS-specific binding specification
 */
export type SyncListResponsePreparedStackOverrideAwResource = {
  /**
   * 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 SyncListResponsePreparedStackOverrideAwStack = {
  /**
   * 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 SyncListResponsePreparedStackOverrideAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: SyncListResponsePreparedStackOverrideAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: SyncListResponsePreparedStackOverrideAwStack | undefined;
};

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

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackOverrideAwGrant = {
  /**
   * 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 SyncListResponsePreparedStackOverrideAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePreparedStackOverrideAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: SyncListResponsePreparedStackOverrideEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePreparedStackOverrideAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackOverrideAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?: SyncListResponsePreparedStackOverrideAzureResource | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: SyncListResponsePreparedStackOverrideAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackOverrideAzureGrant = {
  /**
   * 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 SyncListResponsePreparedStackOverrideAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePreparedStackOverrideAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePreparedStackOverrideAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

export type SyncListResponsePreparedStackOverrideResourceConditionUnion =
  | SyncListResponsePreparedStackOverrideConditionResource
  | any;

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

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

export type SyncListResponsePreparedStackOverrideStackConditionUnion =
  | SyncListResponsePreparedStackOverrideConditionStack
  | any;

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackOverrideGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?: SyncListResponsePreparedStackOverrideGcpResource | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: SyncListResponsePreparedStackOverrideGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackOverrideGcpGrant = {
  /**
   * 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 SyncListResponsePreparedStackOverrideGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePreparedStackOverrideGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePreparedStackOverrideGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePreparedStackOverridePlatforms = {
  /**
   * AWS permission configurations
   */
  aws?: Array<SyncListResponsePreparedStackOverrideAw> | null | undefined;
  /**
   * Azure permission configurations
   */
  azure?: Array<SyncListResponsePreparedStackOverrideAzure> | null | undefined;
  /**
   * GCP permission configurations
   */
  gcp?: Array<SyncListResponsePreparedStackOverrideGcp> | null | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePreparedStackOverride = {
  /**
   * 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: SyncListResponsePreparedStackOverridePlatforms;
};

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

export type SyncListResponsePreparedStackManagement2 = {
  /**
   * 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<SyncListResponsePreparedStackOverride | string>;
  };
};

/**
 * AWS-specific binding specification
 */
export type SyncListResponsePreparedStackExtendAwResource = {
  /**
   * 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 SyncListResponsePreparedStackExtendAwStack = {
  /**
   * 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 SyncListResponsePreparedStackExtendAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: SyncListResponsePreparedStackExtendAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: SyncListResponsePreparedStackExtendAwStack | undefined;
};

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

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackExtendAwGrant = {
  /**
   * 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 SyncListResponsePreparedStackExtendAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePreparedStackExtendAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: SyncListResponsePreparedStackExtendEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePreparedStackExtendAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackExtendAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?: SyncListResponsePreparedStackExtendAzureResource | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: SyncListResponsePreparedStackExtendAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackExtendAzureGrant = {
  /**
   * 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 SyncListResponsePreparedStackExtendAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePreparedStackExtendAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePreparedStackExtendAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

export type SyncListResponsePreparedStackExtendResourceConditionUnion =
  | SyncListResponsePreparedStackExtendConditionResource
  | any;

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

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

export type SyncListResponsePreparedStackExtendStackConditionUnion =
  | SyncListResponsePreparedStackExtendConditionStack
  | any;

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackExtendGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?: SyncListResponsePreparedStackExtendGcpResource | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: SyncListResponsePreparedStackExtendGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackExtendGcpGrant = {
  /**
   * 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 SyncListResponsePreparedStackExtendGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePreparedStackExtendGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePreparedStackExtendGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePreparedStackExtendPlatforms = {
  /**
   * AWS permission configurations
   */
  aws?: Array<SyncListResponsePreparedStackExtendAw> | null | undefined;
  /**
   * Azure permission configurations
   */
  azure?: Array<SyncListResponsePreparedStackExtendAzure> | null | undefined;
  /**
   * GCP permission configurations
   */
  gcp?: Array<SyncListResponsePreparedStackExtendGcp> | null | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePreparedStackExtend = {
  /**
   * 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: SyncListResponsePreparedStackExtendPlatforms;
};

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

export type SyncListResponsePreparedStackManagement1 = {
  /**
   * 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<SyncListResponsePreparedStackExtend | string> };
};

/**
 * Management permissions configuration for stack management access
 */
export type SyncListResponsePreparedStackManagementUnion =
  | SyncListResponsePreparedStackManagement1
  | SyncListResponsePreparedStackManagement2
  | SyncListResponsePreparedStackManagementEnum;

/**
 * AWS-specific binding specification
 */
export type SyncListResponsePreparedStackProfileAwResource = {
  /**
   * 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 SyncListResponsePreparedStackProfileAwStack = {
  /**
   * 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 SyncListResponsePreparedStackProfileAwBinding = {
  /**
   * AWS-specific binding specification
   */
  resource?: SyncListResponsePreparedStackProfileAwResource | undefined;
  /**
   * AWS-specific binding specification
   */
  stack?: SyncListResponsePreparedStackProfileAwStack | undefined;
};

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

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackProfileAwGrant = {
  /**
   * 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 SyncListResponsePreparedStackProfileAw = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePreparedStackProfileAwBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * IAM effect. Defaults to Allow.
   */
  effect?: SyncListResponsePreparedStackProfileEffect | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePreparedStackProfileAwGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackProfileAzureBinding = {
  /**
   * Azure-specific binding specification
   */
  resource?: SyncListResponsePreparedStackProfileAzureResource | undefined;
  /**
   * Azure-specific binding specification
   */
  stack?: SyncListResponsePreparedStackProfileAzureStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackProfileAzureGrant = {
  /**
   * 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 SyncListResponsePreparedStackProfileAzure = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePreparedStackProfileAzureBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePreparedStackProfileAzureGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

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

export type SyncListResponsePreparedStackProfileResourceConditionUnion =
  | SyncListResponsePreparedStackProfileConditionResource
  | any;

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

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

export type SyncListResponsePreparedStackProfileStackConditionUnion =
  | SyncListResponsePreparedStackProfileConditionStack
  | any;

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

/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackProfileGcpBinding = {
  /**
   * GCP-specific binding specification
   */
  resource?: SyncListResponsePreparedStackProfileGcpResource | undefined;
  /**
   * GCP-specific binding specification
   */
  stack?: SyncListResponsePreparedStackProfileGcpStack | undefined;
};

/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackProfileGcpGrant = {
  /**
   * 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 SyncListResponsePreparedStackProfileGcp = {
  /**
   * Generic binding configuration for permissions
   */
  binding: SyncListResponsePreparedStackProfileGcpBinding;
  /**
   * Short admin-facing description of why this entry exists.
   */
  description?: string | null | undefined;
  /**
   * Grant permissions for a specific cloud platform
   */
  grant: SyncListResponsePreparedStackProfileGcpGrant;
  /**
   * Stable admin-facing label for this permission entry.
   */
  label?: string | null | undefined;
};

/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePreparedStackProfilePlatforms = {
  /**
   * AWS permission configurations
   */
  aws?: Array<SyncListResponsePreparedStackProfileAw> | null | undefined;
  /**
   * Azure permission configurations
   */
  azure?: Array<SyncListResponsePreparedStackProfileAzure> | null | undefined;
  /**
   * GCP permission configurations
   */
  gcp?: Array<SyncListResponsePreparedStackProfileGcp> | null | undefined;
};

/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePreparedStackProfile = {
  /**
   * 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: SyncListResponsePreparedStackProfilePlatforms;
};

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

/**
 * Combined permissions configuration that contains both profiles and management
 */
export type SyncListResponsePreparedStackPermissions = {
  /**
   * Management permissions configuration for stack management access
   */
  management?:
    | SyncListResponsePreparedStackManagement1
    | SyncListResponsePreparedStackManagement2
    | SyncListResponsePreparedStackManagementEnum
    | 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<SyncListResponsePreparedStackProfile | 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 SyncListResponsePreparedStackConfig = {
  /**
   * 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 SyncListResponsePreparedStackDependency = {
  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 SyncListResponsePreparedStackLifecycle = {
  Frozen: "frozen",
  Live: "live",
} as const;
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export type SyncListResponsePreparedStackLifecycle = ClosedEnum<
  typeof SyncListResponsePreparedStackLifecycle
>;

export type SyncListResponsePreparedStackResources = {
  /**
   * 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: SyncListResponsePreparedStackConfig;
  /**
   * Additional dependencies for this resource beyond those defined in the resource itself.
   *
   * @remarks
   * The total dependencies are: resource.get_dependencies() + this list
   */
  dependencies: Array<SyncListResponsePreparedStackDependency>;
  /**
   * 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: SyncListResponsePreparedStackLifecycle;
  /**
   * 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 SyncListResponsePreparedStackSupportedPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Local: "local",
  Test: "test",
} as const;
/**
 * Represents the target cloud platform.
 */
export type SyncListResponsePreparedStackSupportedPlatform = ClosedEnum<
  typeof SyncListResponsePreparedStackSupportedPlatform
>;

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

export type SyncListResponsePreparedStackUnion =
  | SyncListResponsePreparedStack
  | any;

/**
 * One-shot authority for a setup re-import to replace setup-owned resources.
 */
export type SyncListResponseSetupUpdateAuthorization = {
  /**
   * 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 SyncListResponseSetupUpdateAuthorizationUnion =
  | SyncListResponseSetupUpdateAuthorization
  | any;

/**
 * Runtime metadata for deployment state persistence
 */
export type SyncListResponseRuntimeMetadata = {
  /**
   * 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?: SyncListResponseInitialSetupAuthority | 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?:
    | SyncListResponsePendingPreparedStack
    | 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?: SyncListResponsePreparedStack | 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?:
    | SyncListResponseSetupUpdateAuthorization
    | any
    | null
    | undefined;
};

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

/**
 * Setup method that created the deployment record and owns setup-time resources.
 */
export const SyncListResponseSetupMethod = {
  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 SyncListResponseSetupMethod = ClosedEnum<
  typeof SyncListResponseSetupMethod
>;

/**
 * Latest error information if the deployment is in a failed state
 */
export type SyncListResponseError = {
  /**
   * 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 SyncListResponseUpdateState = {
  active: DeploymentUpdateOperationSummary | null;
  next: DeploymentUpdateOperationSummary | null;
  latest: DeploymentUpdateOperationSummary | null;
};

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

export type SyncListResponseManagementConfigKubernetes = {
  platform: SyncListResponsePlatformKubernetes;
};

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

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

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

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

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

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

/**
 * Management configuration for different cloud platforms.
 *
 * @remarks
 *
 * Platform-derived configuration for cross-account/cross-tenant access.
 * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
 */
export type SyncListResponseManagementConfigUnion =
  | SyncListResponseManagementConfigAzure
  | SyncListResponseManagementConfigAws
  | SyncListResponseManagementConfigGcp
  | SyncListResponseManagementConfigKubernetes
  | any;

export type SyncListResponseDeployment = {
  /**
   * 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: SyncListResponseStatus;
  /**
   * Unique identifier for the project.
   */
  projectId: string;
  /**
   * Target platform for the deployment
   */
  platform: SyncListResponsePlatform;
  /**
   * Underlying cloud platform for Kubernetes deployments.
   */
  basePlatform?: SyncListResponseBasePlatform | 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?:
    | SyncListResponseEnvironmentInfoGcp
    | SyncListResponseEnvironmentInfoAzure
    | SyncListResponseEnvironmentInfoLocal
    | SyncListResponseEnvironmentInfoAws
    | SyncListResponseEnvironmentInfoTest
    | any
    | null
    | undefined;
  /**
   * User-provided configuration (network, deployment model, approvals)
   */
  stackSettings: SyncListResponseStackSettings;
  /**
   * State of infrastructure components managed by this deployment
   */
  stackState?: SyncListResponseStackState | null | undefined;
  /**
   * Runtime metadata for deployment state persistence
   */
  runtimeMetadata?: SyncListResponseRuntimeMetadata | 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?: SyncListResponseImportSource | null | undefined;
  /**
   * Setup method that created the deployment record and owns setup-time resources.
   */
  setupMethod?: SyncListResponseSetupMethod | 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?: SyncListResponseError | null | undefined;
  /**
   * Durable progress for deployment updates
   */
  updateState?: SyncListResponseUpdateState | undefined;
  createdAt: Date;
  updatedAt: Date;
  managerId: string;
  /**
   * Unique identifier for the workspace.
   */
  workspaceId: string;
  userEnvironmentVariables: Array<EnvironmentVariableConfig> | null;
  /**
   * Management configuration for different cloud platforms.
   *
   * @remarks
   *
   * Platform-derived configuration for cross-account/cross-tenant access.
   * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
   */
  managementConfig?:
    | SyncListResponseManagementConfigAzure
    | SyncListResponseManagementConfigAws
    | SyncListResponseManagementConfigGcp
    | SyncListResponseManagementConfigKubernetes
    | any
    | null
    | undefined;
  deploymentToken?: string | null | undefined;
  lockedBy?: string | null | undefined;
  lockedAt?: Date | null | undefined;
};

/**
 * Full deployment records for manager operation
 */
export type SyncListResponse = {
  deployments: Array<SyncListResponseDeployment>;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponseEnvironmentInfoUnion$inboundSchema: z.ZodType<
  SyncListResponseEnvironmentInfoUnion,
  unknown
> = z.union([
  z.lazy(() => SyncListResponseEnvironmentInfoGcp$inboundSchema),
  z.lazy(() => SyncListResponseEnvironmentInfoAzure$inboundSchema),
  z.lazy(() => SyncListResponseEnvironmentInfoLocal$inboundSchema),
  z.lazy(() => SyncListResponseEnvironmentInfoAws$inboundSchema),
  z.lazy(() => SyncListResponseEnvironmentInfoTest$inboundSchema),
  z.any(),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponseDomainsCertificate$inboundSchema: z.ZodType<
  SyncListResponseDomainsCertificate,
  unknown
> = z.object({
  aws: z.nullable(
    z.union([z.lazy(() => SyncListResponseAws$inboundSchema), z.any()]),
  ).optional(),
  azure: z.nullable(
    z.union([
      z.lazy(() => SyncListResponseAzureStackSettings$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  gcp: z.nullable(
    z.union([
      z.lazy(() => SyncListResponseGcpStackSettings$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  kubernetes: z.nullable(
    z.union([
      z.lazy(() => SyncListResponseDomainsKubernetes$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponseCertificateUnion2$inboundSchema: z.ZodType<
  SyncListResponseCertificateUnion2,
  unknown
> = z.union([
  z.lazy(() => SyncListResponseCertificateTLSSecretRef2$inboundSchema),
  z.lazy(() => SyncListResponseCertificateManagedAcmImport2$inboundSchema),
  z.lazy(() => SyncListResponseCertificateAwsAcmArn2$inboundSchema),
  z.lazy(() => SyncListResponseCertificateManagedTLSSecret2$inboundSchema),
  z.lazy(() => SyncListResponseCertificateNone2$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponseExposureCustom$inboundSchema: z.ZodType<
  SyncListResponseExposureCustom,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => SyncListResponseCertificateTLSSecretRef2$inboundSchema),
    z.lazy(() => SyncListResponseCertificateManagedAcmImport2$inboundSchema),
    z.lazy(() => SyncListResponseCertificateAwsAcmArn2$inboundSchema),
    z.lazy(() => SyncListResponseCertificateManagedTLSSecret2$inboundSchema),
    z.lazy(() => SyncListResponseCertificateNone2$inboundSchema),
  ]),
  domain: z.string(),
  mode: SyncListResponseModeCustom$inboundSchema,
  route: z.union([
    z.lazy(() => SyncListResponseRouteIngress2$inboundSchema),
    z.lazy(() => SyncListResponseRouteGateway2$inboundSchema),
  ]),
});

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponseCertificateUnion1$inboundSchema: z.ZodType<
  SyncListResponseCertificateUnion1,
  unknown
> = z.union([
  z.lazy(() => SyncListResponseCertificateTLSSecretRef1$inboundSchema),
  z.lazy(() => SyncListResponseCertificateManagedAcmImport1$inboundSchema),
  z.lazy(() => SyncListResponseCertificateAwsAcmArn1$inboundSchema),
  z.lazy(() => SyncListResponseCertificateManagedTLSSecret1$inboundSchema),
  z.lazy(() => SyncListResponseCertificateNone1$inboundSchema),
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponseExposureGenerated$inboundSchema: z.ZodType<
  SyncListResponseExposureGenerated,
  unknown
> = z.object({
  certificate: z.union([
    z.lazy(() => SyncListResponseCertificateTLSSecretRef1$inboundSchema),
    z.lazy(() => SyncListResponseCertificateManagedAcmImport1$inboundSchema),
    z.lazy(() => SyncListResponseCertificateAwsAcmArn1$inboundSchema),
    z.lazy(() => SyncListResponseCertificateManagedTLSSecret1$inboundSchema),
    z.lazy(() => SyncListResponseCertificateNone1$inboundSchema),
  ]),
  mode: SyncListResponseModeGenerated$inboundSchema,
  route: z.union([
    z.lazy(() => SyncListResponseRouteIngress1$inboundSchema),
    z.lazy(() => SyncListResponseRouteGateway1$inboundSchema),
  ]),
});

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

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

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

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

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

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

/** @internal */
export const SyncListResponseKubernetes$inboundSchema: z.ZodType<
  SyncListResponseKubernetes,
  unknown
> = z.object({
  cluster: z.nullable(
    z.union([z.lazy(() => SyncListResponseCluster$inboundSchema), z.any()]),
  ).optional(),
  exposure: z.nullable(
    z.union([
      z.lazy(() => SyncListResponseExposureCustom$inboundSchema),
      z.lazy(() => SyncListResponseExposureGenerated$inboundSchema),
      z.lazy(() => SyncListResponseExposureDisabled$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponseNetworkUnion$inboundSchema: z.ZodType<
  SyncListResponseNetworkUnion,
  unknown
> = z.union([
  z.lazy(() => SyncListResponseNetworkByoVpcAws$inboundSchema),
  z.lazy(() => SyncListResponseNetworkByoVpcGcp$inboundSchema),
  z.lazy(() => SyncListResponseNetworkByoVnetAzure$inboundSchema),
  z.lazy(() => SyncListResponseNetworkUseDefault$inboundSchema),
  z.lazy(() => SyncListResponseNetworkCreate$inboundSchema),
  z.any(),
]);

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

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

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

/** @internal */
export const SyncListResponseStackSettings$inboundSchema: z.ZodType<
  SyncListResponseStackSettings,
  unknown
> = z.object({
  compute: z.nullable(
    z.union([z.lazy(() => SyncListResponseCompute$inboundSchema), z.any()]),
  ).optional(),
  deploymentModel: SyncListResponseDeploymentModel$inboundSchema.optional(),
  domains: z.nullable(
    z.union([z.lazy(() => SyncListResponseDomains$inboundSchema), z.any()]),
  ).optional(),
  externalBindings: z.nullable(
    z.lazy(() => SyncListResponseExternalBindings$inboundSchema),
  ).optional(),
  heartbeats: SyncListResponseHeartbeats$inboundSchema.optional(),
  kubernetes: z.nullable(
    z.union([z.lazy(() => SyncListResponseKubernetes$inboundSchema), z.any()]),
  ).optional(),
  network: z.nullable(
    z.union([
      z.lazy(() => SyncListResponseNetworkByoVpcAws$inboundSchema),
      z.lazy(() => SyncListResponseNetworkByoVpcGcp$inboundSchema),
      z.lazy(() => SyncListResponseNetworkByoVnetAzure$inboundSchema),
      z.lazy(() => SyncListResponseNetworkUseDefault$inboundSchema),
      z.lazy(() => SyncListResponseNetworkCreate$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  publicEndpoints: z.nullable(
    z.record(z.string(), z.record(z.string(), z.string())),
  ).optional(),
  telemetry: SyncListResponseTelemetry$inboundSchema.optional(),
  updates: SyncListResponseUpdates$inboundSchema.optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponseStackStateResources$inboundSchema: z.ZodType<
  SyncListResponseStackStateResources,
  unknown
> = z.object({
  _internal: z.nullable(z.any()).optional(),
  config: z.lazy(() => SyncListResponseStackStateConfig$inboundSchema),
  controllerPlatform: z.nullable(
    z.union([SyncListResponseControllerPlatformEnum$inboundSchema, z.any()]),
  ).optional(),
  dependencies: z.array(
    z.lazy(() => SyncListResponseStackStateDependency$inboundSchema),
  ).optional(),
  error: z.nullable(
    z.union([
      z.lazy(() => SyncListResponseErrorStackState$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  lastFailedState: z.nullable(z.any()).optional(),
  lifecycle: z.nullable(
    z.union([SyncListResponseLifecycleStackStateEnum$inboundSchema, z.any()]),
  ).optional(),
  outputs: z.nullable(
    z.union([z.lazy(() => SyncListResponseOutputs$inboundSchema), z.any()]),
  ).optional(),
  previousConfig: z.nullable(
    z.union([
      z.lazy(() => SyncListResponsePreviousConfig$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  remoteBindingParams: z.nullable(z.any()).optional(),
  retryAttempt: z.int().optional(),
  status: SyncListResponseStackStateStatus$inboundSchema,
  type: z.string(),
}).transform((v) => {
  return remap$(v, {
    "_internal": "internal",
  });
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePendingPreparedStackDefaultUnion$inboundSchema:
  z.ZodType<SyncListResponsePendingPreparedStackDefaultUnion, unknown> = z
    .union([
      z.lazy(() =>
        SyncListResponsePendingPreparedStackDefaultString$inboundSchema
      ),
      z.lazy(() =>
        SyncListResponsePendingPreparedStackDefaultNumber$inboundSchema
      ),
      z.lazy(() =>
        SyncListResponsePendingPreparedStackDefaultBoolean$inboundSchema
      ),
      z.lazy(() =>
        SyncListResponsePendingPreparedStackDefaultStringList$inboundSchema
      ),
      z.any(),
    ]);

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePendingPreparedStackInput$inboundSchema: z.ZodType<
  SyncListResponsePendingPreparedStackInput,
  unknown
> = z.object({
  default: z.nullable(
    z.union([
      z.lazy(() =>
        SyncListResponsePendingPreparedStackDefaultString$inboundSchema
      ),
      z.lazy(() =>
        SyncListResponsePendingPreparedStackDefaultNumber$inboundSchema
      ),
      z.lazy(() =>
        SyncListResponsePendingPreparedStackDefaultBoolean$inboundSchema
      ),
      z.lazy(() =>
        SyncListResponsePendingPreparedStackDefaultStringList$inboundSchema
      ),
      z.any(),
    ]),
  ).optional(),
  description: z.string(),
  env: z.array(
    z.lazy(() => SyncListResponsePendingPreparedStackEnv$inboundSchema),
  ).optional(),
  id: z.string(),
  kind: SyncListResponsePendingPreparedStackKind$inboundSchema,
  label: z.string(),
  placeholder: z.nullable(z.string()).optional(),
  platforms: z.nullable(
    z.array(SyncListResponsePendingPreparedStackPlatform$inboundSchema),
  ).optional(),
  providedBy: z.array(
    SyncListResponsePendingPreparedStackProvidedBy$inboundSchema,
  ),
  required: z.boolean(),
  validation: z.nullable(
    z.union([
      z.lazy(() =>
        SyncListResponsePendingPreparedStackValidation$inboundSchema
      ),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePendingPreparedStackOverridePlatforms$inboundSchema:
  z.ZodType<SyncListResponsePendingPreparedStackOverridePlatforms, unknown> = z
    .object({
      aws: z.nullable(
        z.array(z.lazy(() =>
          SyncListResponsePendingPreparedStackOverrideAw$inboundSchema
        )),
      ).optional(),
      azure: z.nullable(
        z.array(z.lazy(() =>
          SyncListResponsePendingPreparedStackOverrideAzure$inboundSchema
        )),
      ).optional(),
      gcp: z.nullable(
        z.array(z.lazy(() =>
          SyncListResponsePendingPreparedStackOverrideGcp$inboundSchema
        )),
      ).optional(),
    });

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePendingPreparedStackExtendPlatforms$inboundSchema:
  z.ZodType<SyncListResponsePendingPreparedStackExtendPlatforms, unknown> = z
    .object({
      aws: z.nullable(
        z.array(z.lazy(() =>
          SyncListResponsePendingPreparedStackExtendAw$inboundSchema
        )),
      ).optional(),
      azure: z.nullable(
        z.array(z.lazy(() =>
          SyncListResponsePendingPreparedStackExtendAzure$inboundSchema
        )),
      ).optional(),
      gcp: z.nullable(
        z.array(z.lazy(() =>
          SyncListResponsePendingPreparedStackExtendGcp$inboundSchema
        )),
      ).optional(),
    });

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePendingPreparedStackManagementUnion$inboundSchema:
  z.ZodType<SyncListResponsePendingPreparedStackManagementUnion, unknown> = z
    .union([
      z.lazy(() =>
        SyncListResponsePendingPreparedStackManagement1$inboundSchema
      ),
      z.lazy(() =>
        SyncListResponsePendingPreparedStackManagement2$inboundSchema
      ),
      SyncListResponsePendingPreparedStackManagementEnum$inboundSchema,
    ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePendingPreparedStackProfilePlatforms$inboundSchema:
  z.ZodType<SyncListResponsePendingPreparedStackProfilePlatforms, unknown> = z
    .object({
      aws: z.nullable(
        z.array(z.lazy(() =>
          SyncListResponsePendingPreparedStackProfileAw$inboundSchema
        )),
      ).optional(),
      azure: z.nullable(
        z.array(z.lazy(() =>
          SyncListResponsePendingPreparedStackProfileAzure$inboundSchema
        )),
      ).optional(),
      gcp: z.nullable(
        z.array(z.lazy(() =>
          SyncListResponsePendingPreparedStackProfileGcp$inboundSchema
        )),
      ).optional(),
    });

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

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

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

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

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

/** @internal */
export const SyncListResponsePendingPreparedStackPermissions$inboundSchema:
  z.ZodType<SyncListResponsePendingPreparedStackPermissions, unknown> = z
    .object({
      management: z.union([
        z.lazy(() =>
          SyncListResponsePendingPreparedStackManagement1$inboundSchema
        ),
        z.lazy(() =>
          SyncListResponsePendingPreparedStackManagement2$inboundSchema
        ),
        SyncListResponsePendingPreparedStackManagementEnum$inboundSchema,
      ]).optional(),
      profiles: z.record(
        z.string(),
        z.record(
          z.string(),
          z.array(
            z.union([
              z.lazy(() =>
                SyncListResponsePendingPreparedStackProfile$inboundSchema
              ),
              z.string(),
            ]),
          ),
        ),
      ),
    });

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePendingPreparedStack$inboundSchema: z.ZodType<
  SyncListResponsePendingPreparedStack,
  unknown
> = z.object({
  id: z.string(),
  inputs: z.array(
    z.lazy(() => SyncListResponsePendingPreparedStackInput$inboundSchema),
  ).optional(),
  permissions: z.lazy(() =>
    SyncListResponsePendingPreparedStackPermissions$inboundSchema
  ).optional(),
  resources: z.record(
    z.string(),
    z.lazy(() => SyncListResponsePendingPreparedStackResources$inboundSchema),
  ),
  supportedPlatforms: z.nullable(
    z.array(
      SyncListResponsePendingPreparedStackSupportedPlatform$inboundSchema,
    ),
  ).optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePreparedStackDefaultUnion$inboundSchema: z.ZodType<
  SyncListResponsePreparedStackDefaultUnion,
  unknown
> = z.union([
  z.lazy(() => SyncListResponsePreparedStackDefaultString$inboundSchema),
  z.lazy(() => SyncListResponsePreparedStackDefaultNumber$inboundSchema),
  z.lazy(() => SyncListResponsePreparedStackDefaultBoolean$inboundSchema),
  z.lazy(() => SyncListResponsePreparedStackDefaultStringList$inboundSchema),
  z.any(),
]);

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePreparedStackInput$inboundSchema: z.ZodType<
  SyncListResponsePreparedStackInput,
  unknown
> = z.object({
  default: z.nullable(
    z.union([
      z.lazy(() => SyncListResponsePreparedStackDefaultString$inboundSchema),
      z.lazy(() => SyncListResponsePreparedStackDefaultNumber$inboundSchema),
      z.lazy(() => SyncListResponsePreparedStackDefaultBoolean$inboundSchema),
      z.lazy(() =>
        SyncListResponsePreparedStackDefaultStringList$inboundSchema
      ),
      z.any(),
    ]),
  ).optional(),
  description: z.string(),
  env: z.array(z.lazy(() => SyncListResponsePreparedStackEnv$inboundSchema))
    .optional(),
  id: z.string(),
  kind: SyncListResponsePreparedStackKind$inboundSchema,
  label: z.string(),
  placeholder: z.nullable(z.string()).optional(),
  platforms: z.nullable(
    z.array(SyncListResponsePreparedStackPlatform$inboundSchema),
  ).optional(),
  providedBy: z.array(SyncListResponsePreparedStackProvidedBy$inboundSchema),
  required: z.boolean(),
  validation: z.nullable(
    z.union([
      z.lazy(() => SyncListResponsePreparedStackValidation$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePreparedStackOverridePlatforms$inboundSchema:
  z.ZodType<SyncListResponsePreparedStackOverridePlatforms, unknown> = z.object(
    {
      aws: z.nullable(z.array(z.lazy(() =>
        SyncListResponsePreparedStackOverrideAw$inboundSchema
      ))).optional(),
      azure: z.nullable(z.array(z.lazy(() =>
        SyncListResponsePreparedStackOverrideAzure$inboundSchema
      ))).optional(),
      gcp: z.nullable(z.array(z.lazy(() =>
        SyncListResponsePreparedStackOverrideGcp$inboundSchema
      ))).optional(),
    },
  );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePreparedStackExtendPlatforms$inboundSchema:
  z.ZodType<SyncListResponsePreparedStackExtendPlatforms, unknown> = z.object({
    aws: z.nullable(
      z.array(
        z.lazy(() => SyncListResponsePreparedStackExtendAw$inboundSchema),
      ),
    ).optional(),
    azure: z.nullable(
      z.array(z.lazy(() =>
        SyncListResponsePreparedStackExtendAzure$inboundSchema
      )),
    ).optional(),
    gcp: z.nullable(
      z.array(
        z.lazy(() => SyncListResponsePreparedStackExtendGcp$inboundSchema),
      ),
    ).optional(),
  });

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePreparedStackManagementUnion$inboundSchema:
  z.ZodType<SyncListResponsePreparedStackManagementUnion, unknown> = z.union([
    z.lazy(() => SyncListResponsePreparedStackManagement1$inboundSchema),
    z.lazy(() => SyncListResponsePreparedStackManagement2$inboundSchema),
    SyncListResponsePreparedStackManagementEnum$inboundSchema,
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePreparedStackProfilePlatforms$inboundSchema:
  z.ZodType<SyncListResponsePreparedStackProfilePlatforms, unknown> = z.object({
    aws: z.nullable(
      z.array(
        z.lazy(() => SyncListResponsePreparedStackProfileAw$inboundSchema),
      ),
    ).optional(),
    azure: z.nullable(
      z.array(z.lazy(() =>
        SyncListResponsePreparedStackProfileAzure$inboundSchema
      )),
    ).optional(),
    gcp: z.nullable(
      z.array(
        z.lazy(() => SyncListResponsePreparedStackProfileGcp$inboundSchema),
      ),
    ).optional(),
  });

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

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

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

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

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

/** @internal */
export const SyncListResponsePreparedStackPermissions$inboundSchema: z.ZodType<
  SyncListResponsePreparedStackPermissions,
  unknown
> = z.object({
  management: z.union([
    z.lazy(() => SyncListResponsePreparedStackManagement1$inboundSchema),
    z.lazy(() => SyncListResponsePreparedStackManagement2$inboundSchema),
    SyncListResponsePreparedStackManagementEnum$inboundSchema,
  ]).optional(),
  profiles: z.record(
    z.string(),
    z.record(
      z.string(),
      z.array(
        z.union([
          z.lazy(() => SyncListResponsePreparedStackProfile$inboundSchema),
          z.string(),
        ]),
      ),
    ),
  ),
});

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

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

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponsePreparedStack$inboundSchema: z.ZodType<
  SyncListResponsePreparedStack,
  unknown
> = z.object({
  id: z.string(),
  inputs: z.array(
    z.lazy(() => SyncListResponsePreparedStackInput$inboundSchema),
  ).optional(),
  permissions: z.lazy(() =>
    SyncListResponsePreparedStackPermissions$inboundSchema
  ).optional(),
  resources: z.record(
    z.string(),
    z.lazy(() => SyncListResponsePreparedStackResources$inboundSchema),
  ),
  supportedPlatforms: z.nullable(
    z.array(SyncListResponsePreparedStackSupportedPlatform$inboundSchema),
  ).optional(),
});

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

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

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

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

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

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

/** @internal */
export const SyncListResponseRuntimeMetadata$inboundSchema: z.ZodType<
  SyncListResponseRuntimeMetadata,
  unknown
> = z.object({
  directSetupRevision: z.nullable(z.string()).optional(),
  initialSetupAuthority: SyncListResponseInitialSetupAuthority$inboundSchema
    .optional(),
  lastSyncedEnvVarsHash: z.nullable(z.string()).optional(),
  lastSyncedSecretNames: z.array(z.string()).optional(),
  pendingPreparedStack: z.nullable(
    z.union([
      z.lazy(() => SyncListResponsePendingPreparedStack$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  persistedGateAnswers: z.record(z.string(), z.boolean()).optional(),
  preparedStack: z.nullable(
    z.union([
      z.lazy(() => SyncListResponsePreparedStack$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  registryAccessGranted: z.boolean().optional(),
  setupUpdateAuthorization: z.nullable(
    z.union([
      z.lazy(() => SyncListResponseSetupUpdateAuthorization$inboundSchema),
      z.any(),
    ]),
  ).optional(),
});

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

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

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

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

/** @internal */
export const SyncListResponseUpdateState$inboundSchema: z.ZodType<
  SyncListResponseUpdateState,
  unknown
> = z.object({
  active: z.nullable(DeploymentUpdateOperationSummary$inboundSchema),
  next: z.nullable(DeploymentUpdateOperationSummary$inboundSchema),
  latest: z.nullable(DeploymentUpdateOperationSummary$inboundSchema),
});

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

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

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

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

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

/** @internal */
export const SyncListResponseManagementConfigAzure$inboundSchema: z.ZodType<
  SyncListResponseManagementConfigAzure,
  unknown
> = z.object({
  managingTenantId: z.string(),
  oidcIssuer: z.string(),
  oidcSubject: z.string(),
  platform: SyncListResponseManagementConfigPlatformAzure$inboundSchema,
});

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

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

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

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

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

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

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

/** @internal */
export const SyncListResponseManagementConfigUnion$inboundSchema: z.ZodType<
  SyncListResponseManagementConfigUnion,
  unknown
> = z.union([
  z.lazy(() => SyncListResponseManagementConfigAzure$inboundSchema),
  z.lazy(() => SyncListResponseManagementConfigAws$inboundSchema),
  z.lazy(() => SyncListResponseManagementConfigGcp$inboundSchema),
  z.lazy(() => SyncListResponseManagementConfigKubernetes$inboundSchema),
  z.any(),
]);

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

/** @internal */
export const SyncListResponseDeployment$inboundSchema: z.ZodType<
  SyncListResponseDeployment,
  unknown
> = z.object({
  id: z.string(),
  name: z.string(),
  publicSubdomain: z.nullable(z.string()).optional(),
  status: SyncListResponseStatus$inboundSchema,
  projectId: z.string(),
  platform: SyncListResponsePlatform$inboundSchema,
  basePlatform: z.nullable(SyncListResponseBasePlatform$inboundSchema)
    .optional(),
  region: z.nullable(z.string()).optional(),
  deploymentProtocolVersion: z.int(),
  deploymentGroupId: z.string(),
  purpose: DeploymentPurpose$inboundSchema,
  environmentInfo: z.nullable(
    z.union([
      z.lazy(() => SyncListResponseEnvironmentInfoGcp$inboundSchema),
      z.lazy(() => SyncListResponseEnvironmentInfoAzure$inboundSchema),
      z.lazy(() => SyncListResponseEnvironmentInfoLocal$inboundSchema),
      z.lazy(() => SyncListResponseEnvironmentInfoAws$inboundSchema),
      z.lazy(() => SyncListResponseEnvironmentInfoTest$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  stackSettings: z.lazy(() => SyncListResponseStackSettings$inboundSchema),
  stackState: z.nullable(z.lazy(() => SyncListResponseStackState$inboundSchema))
    .optional(),
  runtimeMetadata: z.nullable(
    z.lazy(() => SyncListResponseRuntimeMetadata$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(SyncListResponseImportSource$inboundSchema)
    .optional(),
  setupMethod: z.nullable(SyncListResponseSetupMethod$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(() => SyncListResponseError$inboundSchema))
    .optional(),
  updateState: z.lazy(() => SyncListResponseUpdateState$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(),
  userEnvironmentVariables: z.nullable(
    z.array(EnvironmentVariableConfig$inboundSchema),
  ),
  managementConfig: z.nullable(
    z.union([
      z.lazy(() => SyncListResponseManagementConfigAzure$inboundSchema),
      z.lazy(() => SyncListResponseManagementConfigAws$inboundSchema),
      z.lazy(() => SyncListResponseManagementConfigGcp$inboundSchema),
      z.lazy(() => SyncListResponseManagementConfigKubernetes$inboundSchema),
      z.any(),
    ]),
  ).optional(),
  deploymentToken: z.nullable(z.string()).optional(),
  lockedBy: z.nullable(z.string()).optional(),
  lockedAt: z.nullable(
    z.iso.datetime({ offset: true }).transform(v => new Date(v)),
  ).optional(),
});

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

/** @internal */
export const SyncListResponse$inboundSchema: z.ZodType<
  SyncListResponse,
  unknown
> = z.object({
  deployments: z.array(z.lazy(() => SyncListResponseDeployment$inboundSchema)),
});

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