@alienplatform/platform-api 3.3.36 → 3.3.38

package/esm/models/synclistresponsependingpreparedstackdefaultstringlist.d.ts

@@ -0,0 +1,2049 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ExternalBindingUnion } from "./externalbindingunion.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 declare const SyncListResponseStatus: {
+    readonly Pending: "pending";
+    readonly PreflightsFailed: "preflights-failed";
+    readonly InitialSetup: "initial-setup";
+    readonly InitialSetupFailed: "initial-setup-failed";
+    readonly Provisioning: "provisioning";
+    readonly WaitingForMachines: "waiting-for-machines";
+    readonly WaitingForSecrets: "waiting-for-secrets";
+    readonly ProvisioningFailed: "provisioning-failed";
+    readonly Running: "running";
+    readonly RefreshFailed: "refresh-failed";
+    readonly UpdatePending: "update-pending";
+    readonly Updating: "updating";
+    readonly UpdateFailed: "update-failed";
+    readonly DeletePending: "delete-pending";
+    readonly Deleting: "deleting";
+    readonly DeleteFailed: "delete-failed";
+    readonly TeardownRequired: "teardown-required";
+    readonly TeardownFailed: "teardown-failed";
+    readonly Deleted: "deleted";
+    readonly Error: "error";
+};
+/**
+ * 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 declare const SyncListResponsePlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+    readonly Kubernetes: "kubernetes";
+    readonly Machines: "machines";
+    readonly Local: "local";
+    readonly Test: "test";
+};
+/**
+ * Target platform for the deployment
+ */
+export type SyncListResponsePlatform = ClosedEnum<typeof SyncListResponsePlatform>;
+/**
+ * Underlying cloud platform for Kubernetes deployments.
+ */
+export declare const SyncListResponseBasePlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+};
+/**
+ * Underlying cloud platform for Kubernetes deployments.
+ */
+export type SyncListResponseBasePlatform = ClosedEnum<typeof SyncListResponseBasePlatform>;
+export declare const SyncListResponsePlatformTest: {
+    readonly Test: "test";
+};
+export type SyncListResponsePlatformTest = ClosedEnum<typeof SyncListResponsePlatformTest>;
+/**
+ * Test platform environment information (mock)
+ */
+export type SyncListResponseEnvironmentInfoTest = {
+    /**
+     * Test identifier for this environment
+     */
+    testId: string;
+    platform: SyncListResponsePlatformTest;
+};
+export declare const SyncListResponsePlatformLocal: {
+    readonly Local: "local";
+};
+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 declare const SyncListResponseEnvironmentInfoPlatformAzure: {
+    readonly Azure: "azure";
+};
+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 declare const SyncListResponseEnvironmentInfoPlatformGcp: {
+    readonly Gcp: "gcp";
+};
+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 declare const SyncListResponseEnvironmentInfoPlatformAws: {
+    readonly Aws: "aws";
+};
+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 | string;
+/**
+ * Deployment-time resource allocation for a container. Omitted fields use release defaults.
+ */
+export type SyncListResponseContainers = {
+    /**
+     * CPU allocation in vCPUs.
+     */
+    cpu?: number | null | undefined;
+    /**
+     * Memory allocation, using binary units such as Mi or Gi.
+     */
+    memory?: string | null | undefined;
+    /**
+     * Persistent volume capacity per replica, in whole GiB. Omitted values
+     *
+     * @remarks
+     * use the release default. Existing volumes can only grow.
+     */
+    volumeSizeGib?: number | null | undefined;
+};
+/**
+ * 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 | string;
+export type SyncListResponsePoolsAutoscale = {
+    failureDomains?: SyncListResponseFailureDomains2 | string | 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 | string;
+export type SyncListResponsePoolsFixed = {
+    failureDomains?: SyncListResponseFailureDomains1 | string | 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 = {
+    /**
+     * Per-replica resources selected within each container's declared ranges.
+     */
+    containers?: {
+        [k: string]: SyncListResponseContainers;
+    } | undefined;
+    /**
+     * Selected compute choices keyed by pool ID.
+     */
+    pools?: {
+        [k: string]: SyncListResponsePoolsFixed | SyncListResponsePoolsAutoscale;
+    } | undefined;
+};
+export type SyncListResponseComputeUnion = SyncListResponseCompute | string;
+/**
+ * Deployment model: how updates are delivered to the remote environment.
+ */
+export declare const SyncListResponseDeploymentModel: {
+    readonly Push: "push";
+    readonly Pull: "pull";
+};
+/**
+ * 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 | string;
+export type SyncListResponseAzureStackSettings = {
+    keyVaultCertificateId: string;
+    keyVaultResourceId?: string | null | undefined;
+};
+export type SyncListResponseAzureUnion = SyncListResponseAzureStackSettings | string;
+export type SyncListResponseGcpStackSettings = {
+    certificateName: string;
+};
+export type SyncListResponseGcpUnion = SyncListResponseGcpStackSettings | string;
+/**
+ * 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 | string;
+/**
+ * Platform-specific certificate references for custom domains.
+ */
+export type SyncListResponseDomainsCertificate = {
+    aws?: SyncListResponseAws | string | null | undefined;
+    azure?: SyncListResponseAzureStackSettings | string | null | undefined;
+    gcp?: SyncListResponseGcpStackSettings | string | null | undefined;
+    kubernetes?: SyncListResponseDomainsKubernetes | string | 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 declare const SyncListResponseModeLoadBalancer: {
+    readonly LoadBalancer: "loadBalancer";
+};
+export type SyncListResponseModeLoadBalancer = ClosedEnum<typeof SyncListResponseModeLoadBalancer>;
+export type SyncListResponsePublicEndpointTargetLoadBalancer = {
+    /**
+     * DNS name or URL for the external load balancer.
+     */
+    cnameTarget: string;
+    mode: SyncListResponseModeLoadBalancer;
+};
+export declare const SyncListResponseModeMachineAddresses: {
+    readonly MachineAddresses: "machineAddresses";
+};
+export type SyncListResponseModeMachineAddresses = ClosedEnum<typeof SyncListResponseModeMachineAddresses>;
+export type SyncListResponsePublicEndpointTargetMachineAddresses = {
+    mode: SyncListResponseModeMachineAddresses;
+};
+export type SyncListResponsePublicEndpointTargetUnion = SyncListResponsePublicEndpointTargetLoadBalancer | SyncListResponsePublicEndpointTargetMachineAddresses | string;
+/**
+ * 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 | string | null | undefined;
+};
+export type SyncListResponseDomainsUnion = SyncListResponseDomains | string;
+/**
+ * Reachability of the deployment's public endpoints, fixed at setup.
+ */
+export declare const SyncListResponseEndpointAccess: {
+    readonly Internet: "internet";
+    readonly Private: "private";
+};
+/**
+ * Reachability of the deployment's public endpoints, fixed at setup.
+ */
+export type SyncListResponseEndpointAccess = ClosedEnum<typeof SyncListResponseEndpointAccess>;
+/**
+ * How heartbeat health checks are handled.
+ */
+export declare const SyncListResponseHeartbeats: {
+    readonly Off: "off";
+    readonly On: "on";
+};
+/**
+ * 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 | string;
+/**
+ * Ownership model for the Kubernetes cluster.
+ */
+export declare const SyncListResponseOwnership: {
+    readonly Managed: "managed";
+    readonly Existing: "existing";
+    readonly External: "external";
+};
+/**
+ * Ownership model for the Kubernetes cluster.
+ */
+export type SyncListResponseOwnership = ClosedEnum<typeof SyncListResponseOwnership>;
+/**
+ * Kubernetes cluster setup settings.
+ */
+export type SyncListResponseCluster = {
+    cloud?: SyncListResponseCloud | string | 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 | string;
+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 declare const SyncListResponseModeCustom: {
+    readonly Custom: "custom";
+};
+export type SyncListResponseModeCustom = ClosedEnum<typeof SyncListResponseModeCustom>;
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainersEnum4: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+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 declare const SyncListResponseProviderGkeGatewayEnum4: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type SyncListResponseProviderGkeGatewayEnum4 = ClosedEnum<typeof SyncListResponseProviderGkeGatewayEnum4>;
+export type SyncListResponseProviderGkeGateway4 = {
+    provider: SyncListResponseProviderGkeGatewayEnum4;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const SyncListResponseProviderAwsAlbEnum4: {
+    readonly AwsAlb: "awsAlb";
+};
+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 | string;
+/**
+ * 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 | string | null | undefined;
+    routeApi: "gateway";
+};
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainersEnum3: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+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 declare const SyncListResponseProviderGkeGatewayEnum3: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type SyncListResponseProviderGkeGatewayEnum3 = ClosedEnum<typeof SyncListResponseProviderGkeGatewayEnum3>;
+export type SyncListResponseProviderGkeGateway3 = {
+    provider: SyncListResponseProviderGkeGatewayEnum3;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const SyncListResponseProviderAwsAlbEnum3: {
+    readonly AwsAlb: "awsAlb";
+};
+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 | string;
+/**
+ * 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 | string | 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 declare const SyncListResponseModeGenerated: {
+    readonly Generated: "generated";
+};
+export type SyncListResponseModeGenerated = ClosedEnum<typeof SyncListResponseModeGenerated>;
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainersEnum2: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+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 declare const SyncListResponseProviderGkeGatewayEnum2: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type SyncListResponseProviderGkeGatewayEnum2 = ClosedEnum<typeof SyncListResponseProviderGkeGatewayEnum2>;
+export type SyncListResponseProviderGkeGateway2 = {
+    provider: SyncListResponseProviderGkeGatewayEnum2;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const SyncListResponseProviderAwsAlbEnum2: {
+    readonly AwsAlb: "awsAlb";
+};
+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 | string;
+/**
+ * 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 | string | null | undefined;
+    routeApi: "gateway";
+};
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainersEnum1: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+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 declare const SyncListResponseProviderGkeGatewayEnum1: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type SyncListResponseProviderGkeGatewayEnum1 = ClosedEnum<typeof SyncListResponseProviderGkeGatewayEnum1>;
+export type SyncListResponseProviderGkeGateway1 = {
+    provider: SyncListResponseProviderGkeGatewayEnum1;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const SyncListResponseProviderAwsAlbEnum1: {
+    readonly AwsAlb: "awsAlb";
+};
+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 | string;
+/**
+ * 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 | string | 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 declare const SyncListResponseModeDisabled: {
+    readonly Disabled: "disabled";
+};
+export type SyncListResponseModeDisabled = ClosedEnum<typeof SyncListResponseModeDisabled>;
+export type SyncListResponseExposureDisabled = {
+    mode: SyncListResponseModeDisabled;
+};
+export type SyncListResponseExposureUnion = SyncListResponseExposureCustom | SyncListResponseExposureGenerated | SyncListResponseExposureDisabled | string;
+/**
+ * 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 | string | null | undefined;
+    exposure?: SyncListResponseExposureCustom | SyncListResponseExposureGenerated | SyncListResponseExposureDisabled | string | null | undefined;
+};
+export type SyncListResponseKubernetesUnion = SyncListResponseKubernetes | string;
+export declare const SyncListResponseTypeByoVnetAzure: {
+    readonly ByoVnetAzure: "byo-vnet-azure";
+};
+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 declare const SyncListResponseTypeByoVpcGcp: {
+    readonly ByoVpcGcp: "byo-vpc-gcp";
+};
+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 declare const SyncListResponseTypeByoVpcAws: {
+    readonly ByoVpcAws: "byo-vpc-aws";
+};
+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 declare const SyncListResponseTypeCreate: {
+    readonly Create: "create";
+};
+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 declare const SyncListResponseTypeUseDefault: {
+    readonly UseDefault: "use-default";
+};
+export type SyncListResponseTypeUseDefault = ClosedEnum<typeof SyncListResponseTypeUseDefault>;
+export type SyncListResponseNetworkUseDefault = {
+    type: SyncListResponseTypeUseDefault;
+};
+export type SyncListResponseNetworkUnion = SyncListResponseNetworkByoVpcAws | SyncListResponseNetworkByoVpcGcp | SyncListResponseNetworkByoVnetAzure | SyncListResponseNetworkUseDefault | SyncListResponseNetworkCreate | string;
+/**
+ * Whether setup remains a separate administrator operation.
+ */
+export declare const SyncListResponseSetupManagement: {
+    readonly Manual: "manual";
+    readonly Automatic: "automatic";
+};
+/**
+ * Whether setup remains a separate administrator operation.
+ */
+export type SyncListResponseSetupManagement = ClosedEnum<typeof SyncListResponseSetupManagement>;
+/**
+ * How telemetry (logs, metrics, traces) is handled.
+ */
+export declare const SyncListResponseTelemetry: {
+    readonly Off: "off";
+    readonly Auto: "auto";
+    readonly ApprovalRequired: "approval-required";
+};
+/**
+ * How telemetry (logs, metrics, traces) is handled.
+ */
+export type SyncListResponseTelemetry = ClosedEnum<typeof SyncListResponseTelemetry>;
+/**
+ * How updates are delivered to the deployment.
+ */
+export declare const SyncListResponseUpdates: {
+    readonly Auto: "auto";
+    readonly ApprovalRequired: "approval-required";
+};
+/**
+ * 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 | string | null | undefined;
+    /**
+     * Deployment model: how updates are delivered to the remote environment.
+     */
+    deploymentModel?: SyncListResponseDeploymentModel | undefined;
+    domains?: SyncListResponseDomains | string | null | undefined;
+    /**
+     * Reachability of the deployment's public endpoints, fixed at setup.
+     */
+    endpointAccess?: SyncListResponseEndpointAccess | undefined;
+    externalBindings?: {
+        [k: string]: ExternalBindingUnion;
+    } | null | undefined;
+    /**
+     * How heartbeat health checks are handled.
+     */
+    heartbeats?: SyncListResponseHeartbeats | undefined;
+    kubernetes?: SyncListResponseKubernetes | string | null | undefined;
+    network?: SyncListResponseNetworkByoVpcAws | SyncListResponseNetworkByoVpcGcp | SyncListResponseNetworkByoVnetAzure | SyncListResponseNetworkUseDefault | SyncListResponseNetworkCreate | string | 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;
+    /**
+     * Provider quota identities whose preflight failures become visible warnings
+     *
+     * @remarks
+     * for this deployment. Checks still run; deploy-time provider limits still apply.
+     * Unknown identities are rejected. An empty list restores normal blocking.
+     */
+    quotaWarningOverrides?: Array<string> | undefined;
+    /**
+     * Whether setup remains a separate administrator operation.
+     */
+    setupManagement?: SyncListResponseSetupManagement | 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 declare const SyncListResponseStackStatePlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+    readonly Kubernetes: "kubernetes";
+    readonly Machines: "machines";
+    readonly Local: "local";
+    readonly Test: "test";
+};
+/**
+ * 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 declare const SyncListResponseControllerPlatformEnum: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+    readonly Kubernetes: "kubernetes";
+    readonly Machines: "machines";
+    readonly Local: "local";
+    readonly Test: "test";
+};
+/**
+ * Represents the target cloud platform.
+ */
+export type SyncListResponseControllerPlatformEnum = ClosedEnum<typeof SyncListResponseControllerPlatformEnum>;
+export type SyncListResponseControllerPlatformUnion = SyncListResponseControllerPlatformEnum | string;
+/**
+ * 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 | string;
+/**
+ * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
+ */
+export declare const SyncListResponseLifecycleStackStateEnum: {
+    readonly Frozen: "frozen";
+    readonly Live: "live";
+};
+/**
+ * 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 | string;
+/**
+ * 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 | 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 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 | string;
+/**
+ * Represents the high-level status of a resource during its lifecycle.
+ */
+export declare const SyncListResponseStackStateStatus: {
+    readonly Pending: "pending";
+    readonly Provisioning: "provisioning";
+    readonly ProvisionFailed: "provision-failed";
+    readonly Running: "running";
+    readonly Updating: "updating";
+    readonly UpdateFailed: "update-failed";
+    readonly Deleting: "deleting";
+    readonly DeleteFailed: "delete-failed";
+    readonly TeardownRequired: "teardown-required";
+    readonly Deleted: "deleted";
+    readonly RefreshFailed: "refresh-failed";
+};
+/**
+ * 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 | string | 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 | string | 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 | string | null | undefined;
+    outputs?: SyncListResponseOutputs | string | null | undefined;
+    previousConfig?: SyncListResponsePreviousConfig | string | 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;
+    };
+};
+/**
+ * Changing phase starts a new window instead of carrying a previous outage forward.
+ */
+export declare const SyncListResponseCredentialRetryStatus: {
+    readonly Pending: "pending";
+    readonly PreflightsFailed: "preflights-failed";
+    readonly InitialSetup: "initial-setup";
+    readonly InitialSetupFailed: "initial-setup-failed";
+    readonly Provisioning: "provisioning";
+    readonly WaitingForMachines: "waiting-for-machines";
+    readonly WaitingForSecrets: "waiting-for-secrets";
+    readonly ProvisioningFailed: "provisioning-failed";
+    readonly Running: "running";
+    readonly RefreshFailed: "refresh-failed";
+    readonly UpdatePending: "update-pending";
+    readonly Updating: "updating";
+    readonly UpdateFailed: "update-failed";
+    readonly DeletePending: "delete-pending";
+    readonly Deleting: "deleting";
+    readonly DeleteFailed: "delete-failed";
+    readonly TeardownRequired: "teardown-required";
+    readonly TeardownFailed: "teardown-failed";
+    readonly Deleted: "deleted";
+    readonly Error: "error";
+};
+/**
+ * Changing phase starts a new window instead of carrying a previous outage forward.
+ */
+export type SyncListResponseCredentialRetryStatus = ClosedEnum<typeof SyncListResponseCredentialRetryStatus>;
+/**
+ * A credential outage's durable retry window, scoped to its deployment phase.
+ */
+export type SyncListResponseCredentialRetry = {
+    /**
+     * First credential failure in this phase; subsequent attempts keep this timestamp.
+     */
+    startedAt: Date;
+    /**
+     * Changing phase starts a new window instead of carrying a previous outage forward.
+     */
+    status: SyncListResponseCredentialRetryStatus;
+};
+/**
+ * Bounded credential retry state shared by all deployment drivers.
+ */
+export type SyncListResponseCredentialRetryUnion = SyncListResponseCredentialRetry | string;
+/**
+ * Commands for a shell family. Values are never sent to the control plane.
+ */
+export type SyncListResponseUnix = {
+    /**
+     * Command with a visible value placeholder; shell history can retain it.
+     */
+    inline: string;
+    /**
+     * Hidden-input command, without the value in shell history or process arguments.
+     */
+    prompt: string;
+};
+/**
+ * Commands for a shell family. Values are never sent to the control plane.
+ */
+export type SyncListResponseWindows = {
+    /**
+     * Command with a visible value placeholder; shell history can retain it.
+     */
+    inline: string;
+    /**
+     * Hidden-input command, without the value in shell history or process arguments.
+     */
+    prompt: string;
+};
+/**
+ * Shell-specific instructions generated beside the secret location.
+ */
+export type SyncListResponseCommands = {
+    /**
+     * Read-only identity check, valid in both shell families.
+     */
+    checkCommand?: string | null | undefined;
+    /**
+     * Expected account, project, subscription or Kubernetes namespace.
+     */
+    target?: string | null | undefined;
+    /**
+     * Commands for a shell family. Values are never sent to the control plane.
+     */
+    unix: SyncListResponseUnix;
+    /**
+     * Commands for a shell family. Values are never sent to the control plane.
+     */
+    windows: SyncListResponseWindows;
+};
+export type SyncListResponseCommandsUnion = SyncListResponseCommands | string;
+/**
+ * The secret store a deployer writes a vault-native secret into.
+ */
+export declare const SyncListResponseStore: {
+    readonly AwsParameterStore: "aws-parameter-store";
+    readonly GcpSecretManager: "gcp-secret-manager";
+    readonly AzureKeyVault: "azure-key-vault";
+    readonly KubernetesSecret: "kubernetes-secret";
+    readonly LocalVault: "local-vault";
+};
+/**
+ * The secret store a deployer writes a vault-native secret into.
+ */
+export type SyncListResponseStore = ClosedEnum<typeof SyncListResponseStore>;
+/**
+ * Where a deployer writes a vault-native secret.
+ */
+export type SyncListResponseLocation = {
+    /**
+     * Command that prompts without echoing and writes the value through stdin.
+     */
+    cliCommand: string;
+    commands?: SyncListResponseCommands | string | null | undefined;
+    /**
+     * Cloud console page where the secret is created, when the store has one.
+     */
+    consoleUrl?: string | null | undefined;
+    /**
+     * Command that deletes the secret. Deleting a deployment keeps the
+     *
+     * @remarks
+     * secrets the deployer wrote, since Alien never owned their values.
+     */
+    deleteCommand?: string | null | undefined;
+    /**
+     * Full name of the secret in that store.
+     */
+    name: string;
+    /**
+     * The secret store a deployer writes a vault-native secret into.
+     */
+    store: SyncListResponseStore;
+    /**
+     * The Azure Key Vault that holds the secret. Other stores resolve `name`
+     *
+     * @remarks
+     * in the stack's own account or project.
+     */
+    vaultName?: string | null | undefined;
+};
+/**
+ * Whether a deployer secret slot holds a usable value. Alien learns this from
+ *
+ * @remarks
+ * metadata only and never reads the value.
+ */
+export declare const SyncListResponseDeployerSecretStatus: {
+    readonly Present: "present";
+    readonly Missing: "missing";
+    readonly Invalid: "invalid";
+};
+/**
+ * Whether a deployer secret slot holds a usable value. Alien learns this from
+ *
+ * @remarks
+ * metadata only and never reads the value.
+ */
+export type SyncListResponseDeployerSecretStatus = ClosedEnum<typeof SyncListResponseDeployerSecretStatus>;
+/**
+ * The state of one deployer secret slot, reported with the deployment.
+ */
+export type SyncListResponseDeployerSecret = {
+    /**
+     * Stack input id.
+     */
+    inputId: string;
+    /**
+     * The input's label.
+     */
+    label: string;
+    /**
+     * Where a deployer writes a vault-native secret.
+     */
+    location: SyncListResponseLocation;
+    /**
+     * Why the slot is invalid.
+     */
+    message?: string | null | undefined;
+    /**
+     * Whether the workload cannot start without it.
+     */
+    required: boolean;
+    /**
+     * Whether a deployer secret slot holds a usable value. Alien learns this from
+     *
+     * @remarks
+     * metadata only and never reads the value.
+     */
+    status: SyncListResponseDeployerSecretStatus;
+    /**
+     * The secret store's version of the present value (never the value or a
+     *
+     * @remarks
+     * hash of it). A new version reaches workloads with the next update.
+     */
+    version?: string | null | undefined;
+};
+/**
+ * Actor that owns structural work during the initial setup phase.
+ */
+export declare const SyncListResponseInitialSetupAuthority: {
+    readonly ImportedHandoff: "importedHandoff";
+    readonly DirectSetup: "directSetup";
+};
+/**
+ * Actor that owns structural work during the initial setup phase.
+ */
+export type SyncListResponseInitialSetupAuthority = ClosedEnum<typeof SyncListResponseInitialSetupAuthority>;
+export declare const SyncListResponsePendingPreparedStackTypeStringList: {
+    readonly StringList: "stringList";
+};
+export type SyncListResponsePendingPreparedStackTypeStringList = ClosedEnum<typeof SyncListResponsePendingPreparedStackTypeStringList>;
+export type SyncListResponsePendingPreparedStackDefaultStringList = {
+    type: SyncListResponsePendingPreparedStackTypeStringList;
+    /**
+     * String list default.
+     */
+    value: Array<string>;
+};
+/** @internal */
+export declare const SyncListResponseStatus$inboundSchema: z.ZodEnum<typeof SyncListResponseStatus>;
+/** @internal */
+export declare const SyncListResponsePlatform$inboundSchema: z.ZodEnum<typeof SyncListResponsePlatform>;
+/** @internal */
+export declare const SyncListResponseBasePlatform$inboundSchema: z.ZodEnum<typeof SyncListResponseBasePlatform>;
+/** @internal */
+export declare const SyncListResponsePlatformTest$inboundSchema: z.ZodEnum<typeof SyncListResponsePlatformTest>;
+/** @internal */
+export declare const SyncListResponseEnvironmentInfoTest$inboundSchema: z.ZodType<SyncListResponseEnvironmentInfoTest, unknown>;
+export declare function syncListResponseEnvironmentInfoTestFromJSON(jsonString: string): SafeParseResult<SyncListResponseEnvironmentInfoTest, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponsePlatformLocal$inboundSchema: z.ZodEnum<typeof SyncListResponsePlatformLocal>;
+/** @internal */
+export declare const SyncListResponseEnvironmentInfoLocal$inboundSchema: z.ZodType<SyncListResponseEnvironmentInfoLocal, unknown>;
+export declare function syncListResponseEnvironmentInfoLocalFromJSON(jsonString: string): SafeParseResult<SyncListResponseEnvironmentInfoLocal, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseEnvironmentInfoPlatformAzure$inboundSchema: z.ZodEnum<typeof SyncListResponseEnvironmentInfoPlatformAzure>;
+/** @internal */
+export declare const SyncListResponseEnvironmentInfoAzure$inboundSchema: z.ZodType<SyncListResponseEnvironmentInfoAzure, unknown>;
+export declare function syncListResponseEnvironmentInfoAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponseEnvironmentInfoAzure, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseEnvironmentInfoPlatformGcp$inboundSchema: z.ZodEnum<typeof SyncListResponseEnvironmentInfoPlatformGcp>;
+/** @internal */
+export declare const SyncListResponseEnvironmentInfoGcp$inboundSchema: z.ZodType<SyncListResponseEnvironmentInfoGcp, unknown>;
+export declare function syncListResponseEnvironmentInfoGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponseEnvironmentInfoGcp, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseEnvironmentInfoPlatformAws$inboundSchema: z.ZodEnum<typeof SyncListResponseEnvironmentInfoPlatformAws>;
+/** @internal */
+export declare const SyncListResponseEnvironmentInfoAws$inboundSchema: z.ZodType<SyncListResponseEnvironmentInfoAws, unknown>;
+export declare function syncListResponseEnvironmentInfoAwsFromJSON(jsonString: string): SafeParseResult<SyncListResponseEnvironmentInfoAws, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseEnvironmentInfoUnion$inboundSchema: z.ZodType<SyncListResponseEnvironmentInfoUnion, unknown>;
+export declare function syncListResponseEnvironmentInfoUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseEnvironmentInfoUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseContainers$inboundSchema: z.ZodType<SyncListResponseContainers, unknown>;
+export declare function syncListResponseContainersFromJSON(jsonString: string): SafeParseResult<SyncListResponseContainers, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseFailureDomains2$inboundSchema: z.ZodType<SyncListResponseFailureDomains2, unknown>;
+export declare function syncListResponseFailureDomains2FromJSON(jsonString: string): SafeParseResult<SyncListResponseFailureDomains2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseFailureDomainsUnion2$inboundSchema: z.ZodType<SyncListResponseFailureDomainsUnion2, unknown>;
+export declare function syncListResponseFailureDomainsUnion2FromJSON(jsonString: string): SafeParseResult<SyncListResponseFailureDomainsUnion2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponsePoolsAutoscale$inboundSchema: z.ZodType<SyncListResponsePoolsAutoscale, unknown>;
+export declare function syncListResponsePoolsAutoscaleFromJSON(jsonString: string): SafeParseResult<SyncListResponsePoolsAutoscale, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseFailureDomains1$inboundSchema: z.ZodType<SyncListResponseFailureDomains1, unknown>;
+export declare function syncListResponseFailureDomains1FromJSON(jsonString: string): SafeParseResult<SyncListResponseFailureDomains1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseFailureDomainsUnion1$inboundSchema: z.ZodType<SyncListResponseFailureDomainsUnion1, unknown>;
+export declare function syncListResponseFailureDomainsUnion1FromJSON(jsonString: string): SafeParseResult<SyncListResponseFailureDomainsUnion1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponsePoolsFixed$inboundSchema: z.ZodType<SyncListResponsePoolsFixed, unknown>;
+export declare function syncListResponsePoolsFixedFromJSON(jsonString: string): SafeParseResult<SyncListResponsePoolsFixed, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponsePoolsUnion$inboundSchema: z.ZodType<SyncListResponsePoolsUnion, unknown>;
+export declare function syncListResponsePoolsUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePoolsUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCompute$inboundSchema: z.ZodType<SyncListResponseCompute, unknown>;
+export declare function syncListResponseComputeFromJSON(jsonString: string): SafeParseResult<SyncListResponseCompute, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseComputeUnion$inboundSchema: z.ZodType<SyncListResponseComputeUnion, unknown>;
+export declare function syncListResponseComputeUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseComputeUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseDeploymentModel$inboundSchema: z.ZodEnum<typeof SyncListResponseDeploymentModel>;
+/** @internal */
+export declare const SyncListResponseAws$inboundSchema: z.ZodType<SyncListResponseAws, unknown>;
+export declare function syncListResponseAwsFromJSON(jsonString: string): SafeParseResult<SyncListResponseAws, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseAwsUnion$inboundSchema: z.ZodType<SyncListResponseAwsUnion, unknown>;
+export declare function syncListResponseAwsUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseAwsUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseAzureStackSettings$inboundSchema: z.ZodType<SyncListResponseAzureStackSettings, unknown>;
+export declare function syncListResponseAzureStackSettingsFromJSON(jsonString: string): SafeParseResult<SyncListResponseAzureStackSettings, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseAzureUnion$inboundSchema: z.ZodType<SyncListResponseAzureUnion, unknown>;
+export declare function syncListResponseAzureUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseAzureUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseGcpStackSettings$inboundSchema: z.ZodType<SyncListResponseGcpStackSettings, unknown>;
+export declare function syncListResponseGcpStackSettingsFromJSON(jsonString: string): SafeParseResult<SyncListResponseGcpStackSettings, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseGcpUnion$inboundSchema: z.ZodType<SyncListResponseGcpUnion, unknown>;
+export declare function syncListResponseGcpUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseGcpUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseTlsSecretRef$inboundSchema: z.ZodType<SyncListResponseTlsSecretRef, unknown>;
+export declare function syncListResponseTlsSecretRefFromJSON(jsonString: string): SafeParseResult<SyncListResponseTlsSecretRef, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseDomainsKubernetes$inboundSchema: z.ZodType<SyncListResponseDomainsKubernetes, unknown>;
+export declare function syncListResponseDomainsKubernetesFromJSON(jsonString: string): SafeParseResult<SyncListResponseDomainsKubernetes, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseDomainsKubernetesUnion$inboundSchema: z.ZodType<SyncListResponseDomainsKubernetesUnion, unknown>;
+export declare function syncListResponseDomainsKubernetesUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseDomainsKubernetesUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseDomainsCertificate$inboundSchema: z.ZodType<SyncListResponseDomainsCertificate, unknown>;
+export declare function syncListResponseDomainsCertificateFromJSON(jsonString: string): SafeParseResult<SyncListResponseDomainsCertificate, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCustomDomains$inboundSchema: z.ZodType<SyncListResponseCustomDomains, unknown>;
+export declare function syncListResponseCustomDomainsFromJSON(jsonString: string): SafeParseResult<SyncListResponseCustomDomains, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseModeLoadBalancer$inboundSchema: z.ZodEnum<typeof SyncListResponseModeLoadBalancer>;
+/** @internal */
+export declare const SyncListResponsePublicEndpointTargetLoadBalancer$inboundSchema: z.ZodType<SyncListResponsePublicEndpointTargetLoadBalancer, unknown>;
+export declare function syncListResponsePublicEndpointTargetLoadBalancerFromJSON(jsonString: string): SafeParseResult<SyncListResponsePublicEndpointTargetLoadBalancer, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseModeMachineAddresses$inboundSchema: z.ZodEnum<typeof SyncListResponseModeMachineAddresses>;
+/** @internal */
+export declare const SyncListResponsePublicEndpointTargetMachineAddresses$inboundSchema: z.ZodType<SyncListResponsePublicEndpointTargetMachineAddresses, unknown>;
+export declare function syncListResponsePublicEndpointTargetMachineAddressesFromJSON(jsonString: string): SafeParseResult<SyncListResponsePublicEndpointTargetMachineAddresses, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponsePublicEndpointTargetUnion$inboundSchema: z.ZodType<SyncListResponsePublicEndpointTargetUnion, unknown>;
+export declare function syncListResponsePublicEndpointTargetUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePublicEndpointTargetUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseDomains$inboundSchema: z.ZodType<SyncListResponseDomains, unknown>;
+export declare function syncListResponseDomainsFromJSON(jsonString: string): SafeParseResult<SyncListResponseDomains, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseDomainsUnion$inboundSchema: z.ZodType<SyncListResponseDomainsUnion, unknown>;
+export declare function syncListResponseDomainsUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseDomainsUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseEndpointAccess$inboundSchema: z.ZodEnum<typeof SyncListResponseEndpointAccess>;
+/** @internal */
+export declare const SyncListResponseHeartbeats$inboundSchema: z.ZodEnum<typeof SyncListResponseHeartbeats>;
+/** @internal */
+export declare const SyncListResponseCloud$inboundSchema: z.ZodType<SyncListResponseCloud, unknown>;
+export declare function syncListResponseCloudFromJSON(jsonString: string): SafeParseResult<SyncListResponseCloud, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCloudUnion$inboundSchema: z.ZodType<SyncListResponseCloudUnion, unknown>;
+export declare function syncListResponseCloudUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseCloudUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOwnership$inboundSchema: z.ZodEnum<typeof SyncListResponseOwnership>;
+/** @internal */
+export declare const SyncListResponseCluster$inboundSchema: z.ZodType<SyncListResponseCluster, unknown>;
+export declare function syncListResponseClusterFromJSON(jsonString: string): SafeParseResult<SyncListResponseCluster, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseClusterUnion$inboundSchema: z.ZodType<SyncListResponseClusterUnion, unknown>;
+export declare function syncListResponseClusterUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseClusterUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateNone2$inboundSchema: z.ZodType<SyncListResponseCertificateNone2, unknown>;
+export declare function syncListResponseCertificateNone2FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateNone2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateManagedTLSSecret2$inboundSchema: z.ZodType<SyncListResponseCertificateManagedTLSSecret2, unknown>;
+export declare function syncListResponseCertificateManagedTLSSecret2FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateManagedTLSSecret2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateAwsAcmArn2$inboundSchema: z.ZodType<SyncListResponseCertificateAwsAcmArn2, unknown>;
+export declare function syncListResponseCertificateAwsAcmArn2FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateAwsAcmArn2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateManagedAcmImport2$inboundSchema: z.ZodType<SyncListResponseCertificateManagedAcmImport2, unknown>;
+export declare function syncListResponseCertificateManagedAcmImport2FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateManagedAcmImport2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateTLSSecretRef2$inboundSchema: z.ZodType<SyncListResponseCertificateTLSSecretRef2, unknown>;
+export declare function syncListResponseCertificateTLSSecretRef2FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateTLSSecretRef2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateUnion2$inboundSchema: z.ZodType<SyncListResponseCertificateUnion2, unknown>;
+export declare function syncListResponseCertificateUnion2FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateUnion2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseModeCustom$inboundSchema: z.ZodEnum<typeof SyncListResponseModeCustom>;
+/** @internal */
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainersEnum4$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderAzureApplicationGatewayForContainersEnum4>;
+/** @internal */
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainers4$inboundSchema: z.ZodType<SyncListResponseProviderAzureApplicationGatewayForContainers4, unknown>;
+export declare function syncListResponseProviderAzureApplicationGatewayForContainers4FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderAzureApplicationGatewayForContainers4, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderGkeGatewayEnum4$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderGkeGatewayEnum4>;
+/** @internal */
+export declare const SyncListResponseProviderGkeGateway4$inboundSchema: z.ZodType<SyncListResponseProviderGkeGateway4, unknown>;
+export declare function syncListResponseProviderGkeGateway4FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderGkeGateway4, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderAwsAlbEnum4$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderAwsAlbEnum4>;
+/** @internal */
+export declare const SyncListResponseProviderAwsAlb4$inboundSchema: z.ZodType<SyncListResponseProviderAwsAlb4, unknown>;
+export declare function syncListResponseProviderAwsAlb4FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderAwsAlb4, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderUnion4$inboundSchema: z.ZodType<SyncListResponseProviderUnion4, unknown>;
+export declare function syncListResponseProviderUnion4FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderUnion4, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseRouteGateway2$inboundSchema: z.ZodType<SyncListResponseRouteGateway2, unknown>;
+export declare function syncListResponseRouteGateway2FromJSON(jsonString: string): SafeParseResult<SyncListResponseRouteGateway2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainersEnum3$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderAzureApplicationGatewayForContainersEnum3>;
+/** @internal */
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainers3$inboundSchema: z.ZodType<SyncListResponseProviderAzureApplicationGatewayForContainers3, unknown>;
+export declare function syncListResponseProviderAzureApplicationGatewayForContainers3FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderAzureApplicationGatewayForContainers3, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderGkeGatewayEnum3$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderGkeGatewayEnum3>;
+/** @internal */
+export declare const SyncListResponseProviderGkeGateway3$inboundSchema: z.ZodType<SyncListResponseProviderGkeGateway3, unknown>;
+export declare function syncListResponseProviderGkeGateway3FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderGkeGateway3, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderAwsAlbEnum3$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderAwsAlbEnum3>;
+/** @internal */
+export declare const SyncListResponseProviderAwsAlb3$inboundSchema: z.ZodType<SyncListResponseProviderAwsAlb3, unknown>;
+export declare function syncListResponseProviderAwsAlb3FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderAwsAlb3, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderUnion3$inboundSchema: z.ZodType<SyncListResponseProviderUnion3, unknown>;
+export declare function syncListResponseProviderUnion3FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderUnion3, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseRouteIngress2$inboundSchema: z.ZodType<SyncListResponseRouteIngress2, unknown>;
+export declare function syncListResponseRouteIngress2FromJSON(jsonString: string): SafeParseResult<SyncListResponseRouteIngress2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseRouteUnion2$inboundSchema: z.ZodType<SyncListResponseRouteUnion2, unknown>;
+export declare function syncListResponseRouteUnion2FromJSON(jsonString: string): SafeParseResult<SyncListResponseRouteUnion2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExposureCustom$inboundSchema: z.ZodType<SyncListResponseExposureCustom, unknown>;
+export declare function syncListResponseExposureCustomFromJSON(jsonString: string): SafeParseResult<SyncListResponseExposureCustom, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateNone1$inboundSchema: z.ZodType<SyncListResponseCertificateNone1, unknown>;
+export declare function syncListResponseCertificateNone1FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateNone1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateManagedTLSSecret1$inboundSchema: z.ZodType<SyncListResponseCertificateManagedTLSSecret1, unknown>;
+export declare function syncListResponseCertificateManagedTLSSecret1FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateManagedTLSSecret1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateAwsAcmArn1$inboundSchema: z.ZodType<SyncListResponseCertificateAwsAcmArn1, unknown>;
+export declare function syncListResponseCertificateAwsAcmArn1FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateAwsAcmArn1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateManagedAcmImport1$inboundSchema: z.ZodType<SyncListResponseCertificateManagedAcmImport1, unknown>;
+export declare function syncListResponseCertificateManagedAcmImport1FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateManagedAcmImport1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateTLSSecretRef1$inboundSchema: z.ZodType<SyncListResponseCertificateTLSSecretRef1, unknown>;
+export declare function syncListResponseCertificateTLSSecretRef1FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateTLSSecretRef1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCertificateUnion1$inboundSchema: z.ZodType<SyncListResponseCertificateUnion1, unknown>;
+export declare function syncListResponseCertificateUnion1FromJSON(jsonString: string): SafeParseResult<SyncListResponseCertificateUnion1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseModeGenerated$inboundSchema: z.ZodEnum<typeof SyncListResponseModeGenerated>;
+/** @internal */
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainersEnum2$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderAzureApplicationGatewayForContainersEnum2>;
+/** @internal */
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainers2$inboundSchema: z.ZodType<SyncListResponseProviderAzureApplicationGatewayForContainers2, unknown>;
+export declare function syncListResponseProviderAzureApplicationGatewayForContainers2FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderAzureApplicationGatewayForContainers2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderGkeGatewayEnum2$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderGkeGatewayEnum2>;
+/** @internal */
+export declare const SyncListResponseProviderGkeGateway2$inboundSchema: z.ZodType<SyncListResponseProviderGkeGateway2, unknown>;
+export declare function syncListResponseProviderGkeGateway2FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderGkeGateway2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderAwsAlbEnum2$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderAwsAlbEnum2>;
+/** @internal */
+export declare const SyncListResponseProviderAwsAlb2$inboundSchema: z.ZodType<SyncListResponseProviderAwsAlb2, unknown>;
+export declare function syncListResponseProviderAwsAlb2FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderAwsAlb2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderUnion2$inboundSchema: z.ZodType<SyncListResponseProviderUnion2, unknown>;
+export declare function syncListResponseProviderUnion2FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderUnion2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseRouteGateway1$inboundSchema: z.ZodType<SyncListResponseRouteGateway1, unknown>;
+export declare function syncListResponseRouteGateway1FromJSON(jsonString: string): SafeParseResult<SyncListResponseRouteGateway1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainersEnum1$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderAzureApplicationGatewayForContainersEnum1>;
+/** @internal */
+export declare const SyncListResponseProviderAzureApplicationGatewayForContainers1$inboundSchema: z.ZodType<SyncListResponseProviderAzureApplicationGatewayForContainers1, unknown>;
+export declare function syncListResponseProviderAzureApplicationGatewayForContainers1FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderAzureApplicationGatewayForContainers1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderGkeGatewayEnum1$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderGkeGatewayEnum1>;
+/** @internal */
+export declare const SyncListResponseProviderGkeGateway1$inboundSchema: z.ZodType<SyncListResponseProviderGkeGateway1, unknown>;
+export declare function syncListResponseProviderGkeGateway1FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderGkeGateway1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderAwsAlbEnum1$inboundSchema: z.ZodEnum<typeof SyncListResponseProviderAwsAlbEnum1>;
+/** @internal */
+export declare const SyncListResponseProviderAwsAlb1$inboundSchema: z.ZodType<SyncListResponseProviderAwsAlb1, unknown>;
+export declare function syncListResponseProviderAwsAlb1FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderAwsAlb1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProviderUnion1$inboundSchema: z.ZodType<SyncListResponseProviderUnion1, unknown>;
+export declare function syncListResponseProviderUnion1FromJSON(jsonString: string): SafeParseResult<SyncListResponseProviderUnion1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseRouteIngress1$inboundSchema: z.ZodType<SyncListResponseRouteIngress1, unknown>;
+export declare function syncListResponseRouteIngress1FromJSON(jsonString: string): SafeParseResult<SyncListResponseRouteIngress1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseRouteUnion1$inboundSchema: z.ZodType<SyncListResponseRouteUnion1, unknown>;
+export declare function syncListResponseRouteUnion1FromJSON(jsonString: string): SafeParseResult<SyncListResponseRouteUnion1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExposureGenerated$inboundSchema: z.ZodType<SyncListResponseExposureGenerated, unknown>;
+export declare function syncListResponseExposureGeneratedFromJSON(jsonString: string): SafeParseResult<SyncListResponseExposureGenerated, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseModeDisabled$inboundSchema: z.ZodEnum<typeof SyncListResponseModeDisabled>;
+/** @internal */
+export declare const SyncListResponseExposureDisabled$inboundSchema: z.ZodType<SyncListResponseExposureDisabled, unknown>;
+export declare function syncListResponseExposureDisabledFromJSON(jsonString: string): SafeParseResult<SyncListResponseExposureDisabled, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExposureUnion$inboundSchema: z.ZodType<SyncListResponseExposureUnion, unknown>;
+export declare function syncListResponseExposureUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseExposureUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseKubernetes$inboundSchema: z.ZodType<SyncListResponseKubernetes, unknown>;
+export declare function syncListResponseKubernetesFromJSON(jsonString: string): SafeParseResult<SyncListResponseKubernetes, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseKubernetesUnion$inboundSchema: z.ZodType<SyncListResponseKubernetesUnion, unknown>;
+export declare function syncListResponseKubernetesUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseKubernetesUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseTypeByoVnetAzure$inboundSchema: z.ZodEnum<typeof SyncListResponseTypeByoVnetAzure>;
+/** @internal */
+export declare const SyncListResponseNetworkByoVnetAzure$inboundSchema: z.ZodType<SyncListResponseNetworkByoVnetAzure, unknown>;
+export declare function syncListResponseNetworkByoVnetAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponseNetworkByoVnetAzure, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseTypeByoVpcGcp$inboundSchema: z.ZodEnum<typeof SyncListResponseTypeByoVpcGcp>;
+/** @internal */
+export declare const SyncListResponseNetworkByoVpcGcp$inboundSchema: z.ZodType<SyncListResponseNetworkByoVpcGcp, unknown>;
+export declare function syncListResponseNetworkByoVpcGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponseNetworkByoVpcGcp, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseTypeByoVpcAws$inboundSchema: z.ZodEnum<typeof SyncListResponseTypeByoVpcAws>;
+/** @internal */
+export declare const SyncListResponseNetworkByoVpcAws$inboundSchema: z.ZodType<SyncListResponseNetworkByoVpcAws, unknown>;
+export declare function syncListResponseNetworkByoVpcAwsFromJSON(jsonString: string): SafeParseResult<SyncListResponseNetworkByoVpcAws, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseTypeCreate$inboundSchema: z.ZodEnum<typeof SyncListResponseTypeCreate>;
+/** @internal */
+export declare const SyncListResponseNetworkCreate$inboundSchema: z.ZodType<SyncListResponseNetworkCreate, unknown>;
+export declare function syncListResponseNetworkCreateFromJSON(jsonString: string): SafeParseResult<SyncListResponseNetworkCreate, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseTypeUseDefault$inboundSchema: z.ZodEnum<typeof SyncListResponseTypeUseDefault>;
+/** @internal */
+export declare const SyncListResponseNetworkUseDefault$inboundSchema: z.ZodType<SyncListResponseNetworkUseDefault, unknown>;
+export declare function syncListResponseNetworkUseDefaultFromJSON(jsonString: string): SafeParseResult<SyncListResponseNetworkUseDefault, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseNetworkUnion$inboundSchema: z.ZodType<SyncListResponseNetworkUnion, unknown>;
+export declare function syncListResponseNetworkUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseNetworkUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseSetupManagement$inboundSchema: z.ZodEnum<typeof SyncListResponseSetupManagement>;
+/** @internal */
+export declare const SyncListResponseTelemetry$inboundSchema: z.ZodEnum<typeof SyncListResponseTelemetry>;
+/** @internal */
+export declare const SyncListResponseUpdates$inboundSchema: z.ZodEnum<typeof SyncListResponseUpdates>;
+/** @internal */
+export declare const SyncListResponseStackSettings$inboundSchema: z.ZodType<SyncListResponseStackSettings, unknown>;
+export declare function syncListResponseStackSettingsFromJSON(jsonString: string): SafeParseResult<SyncListResponseStackSettings, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseStackStatePlatform$inboundSchema: z.ZodEnum<typeof SyncListResponseStackStatePlatform>;
+/** @internal */
+export declare const SyncListResponseStackStateConfig$inboundSchema: z.ZodType<SyncListResponseStackStateConfig, unknown>;
+export declare function syncListResponseStackStateConfigFromJSON(jsonString: string): SafeParseResult<SyncListResponseStackStateConfig, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseControllerPlatformEnum$inboundSchema: z.ZodEnum<typeof SyncListResponseControllerPlatformEnum>;
+/** @internal */
+export declare const SyncListResponseControllerPlatformUnion$inboundSchema: z.ZodType<SyncListResponseControllerPlatformUnion, unknown>;
+export declare function syncListResponseControllerPlatformUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseControllerPlatformUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseStackStateDependency$inboundSchema: z.ZodType<SyncListResponseStackStateDependency, unknown>;
+export declare function syncListResponseStackStateDependencyFromJSON(jsonString: string): SafeParseResult<SyncListResponseStackStateDependency, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseErrorStackState$inboundSchema: z.ZodType<SyncListResponseErrorStackState, unknown>;
+export declare function syncListResponseErrorStackStateFromJSON(jsonString: string): SafeParseResult<SyncListResponseErrorStackState, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseErrorUnion$inboundSchema: z.ZodType<SyncListResponseErrorUnion, unknown>;
+export declare function syncListResponseErrorUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseErrorUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseLifecycleStackStateEnum$inboundSchema: z.ZodEnum<typeof SyncListResponseLifecycleStackStateEnum>;
+/** @internal */
+export declare const SyncListResponseLifecycleUnion$inboundSchema: z.ZodType<SyncListResponseLifecycleUnion, unknown>;
+export declare function syncListResponseLifecycleUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseLifecycleUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOutputs$inboundSchema: z.ZodType<SyncListResponseOutputs, unknown>;
+export declare function syncListResponseOutputsFromJSON(jsonString: string): SafeParseResult<SyncListResponseOutputs, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOutputsUnion$inboundSchema: z.ZodType<SyncListResponseOutputsUnion, unknown>;
+export declare function syncListResponseOutputsUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseOutputsUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponsePreviousConfig$inboundSchema: z.ZodType<SyncListResponsePreviousConfig, unknown>;
+export declare function syncListResponsePreviousConfigFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreviousConfig, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponsePreviousConfigUnion$inboundSchema: z.ZodType<SyncListResponsePreviousConfigUnion, unknown>;
+export declare function syncListResponsePreviousConfigUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreviousConfigUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseStackStateStatus$inboundSchema: z.ZodEnum<typeof SyncListResponseStackStateStatus>;
+/** @internal */
+export declare const SyncListResponseStackStateResources$inboundSchema: z.ZodType<SyncListResponseStackStateResources, unknown>;
+export declare function syncListResponseStackStateResourcesFromJSON(jsonString: string): SafeParseResult<SyncListResponseStackStateResources, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseStackState$inboundSchema: z.ZodType<SyncListResponseStackState, unknown>;
+export declare function syncListResponseStackStateFromJSON(jsonString: string): SafeParseResult<SyncListResponseStackState, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCredentialRetryStatus$inboundSchema: z.ZodEnum<typeof SyncListResponseCredentialRetryStatus>;
+/** @internal */
+export declare const SyncListResponseCredentialRetry$inboundSchema: z.ZodType<SyncListResponseCredentialRetry, unknown>;
+export declare function syncListResponseCredentialRetryFromJSON(jsonString: string): SafeParseResult<SyncListResponseCredentialRetry, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCredentialRetryUnion$inboundSchema: z.ZodType<SyncListResponseCredentialRetryUnion, unknown>;
+export declare function syncListResponseCredentialRetryUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseCredentialRetryUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseUnix$inboundSchema: z.ZodType<SyncListResponseUnix, unknown>;
+export declare function syncListResponseUnixFromJSON(jsonString: string): SafeParseResult<SyncListResponseUnix, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseWindows$inboundSchema: z.ZodType<SyncListResponseWindows, unknown>;
+export declare function syncListResponseWindowsFromJSON(jsonString: string): SafeParseResult<SyncListResponseWindows, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCommands$inboundSchema: z.ZodType<SyncListResponseCommands, unknown>;
+export declare function syncListResponseCommandsFromJSON(jsonString: string): SafeParseResult<SyncListResponseCommands, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseCommandsUnion$inboundSchema: z.ZodType<SyncListResponseCommandsUnion, unknown>;
+export declare function syncListResponseCommandsUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseCommandsUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseStore$inboundSchema: z.ZodEnum<typeof SyncListResponseStore>;
+/** @internal */
+export declare const SyncListResponseLocation$inboundSchema: z.ZodType<SyncListResponseLocation, unknown>;
+export declare function syncListResponseLocationFromJSON(jsonString: string): SafeParseResult<SyncListResponseLocation, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseDeployerSecretStatus$inboundSchema: z.ZodEnum<typeof SyncListResponseDeployerSecretStatus>;
+/** @internal */
+export declare const SyncListResponseDeployerSecret$inboundSchema: z.ZodType<SyncListResponseDeployerSecret, unknown>;
+export declare function syncListResponseDeployerSecretFromJSON(jsonString: string): SafeParseResult<SyncListResponseDeployerSecret, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseInitialSetupAuthority$inboundSchema: z.ZodEnum<typeof SyncListResponseInitialSetupAuthority>;
+/** @internal */
+export declare const SyncListResponsePendingPreparedStackTypeStringList$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackTypeStringList>;
+/** @internal */
+export declare const SyncListResponsePendingPreparedStackDefaultStringList$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackDefaultStringList, unknown>;
+export declare function syncListResponsePendingPreparedStackDefaultStringListFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackDefaultStringList, SDKValidationError>;
+//# sourceMappingURL=synclistresponsependingpreparedstackdefaultstringlist.d.ts.map