import * as z from "zod/v4";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import { DeploymentPurpose } from "./deploymentpurpose.js";
import { DeploymentUpdateOperationSummary } from "./deploymentupdateoperationsummary.js";
import { EnvironmentVariableConfig } from "./environmentvariableconfig.js";
import { SDKValidationError } from "./errors/sdkvalidationerror.js";
import { OperatorCapabilityReport } from "./operatorcapabilityreport.js";
import { ReportedOperation } from "./reportedoperation.js";
/**
 * Deployment status in the deployment lifecycle.
 *
 * @remarks
 *
 * For observe-only deployments with no release or stack state, `Running`
 * means the Operator is attached. Connectivity comes from `lastHeartbeatAt`;
 * resource health comes from inventory and resource heartbeat data.
 */
export 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 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 | any;
/**
 * Failure-domain policy selected for a compute pool.
 */
export type SyncListResponseFailureDomains2 = {
    /**
     * Concrete provider domains selected during setup.
     *
     * @remarks
     * Empty delegates deterministic selection to the provider setup implementation.
     */
    selectedFailureDomains?: Array<string> | undefined;
    /**
     * Number of distinct failure domains across which new stateful replicas may be spread.
     */
    spread: number;
};
export type SyncListResponseFailureDomainsUnion2 = SyncListResponseFailureDomains2 | any;
export type SyncListResponsePoolsAutoscale = {
    failureDomains?: SyncListResponseFailureDomains2 | any | null | undefined;
    /**
     * Provider machine type selected for this deployment.
     */
    machine?: string | null | undefined;
    /**
     * Maximum machine count.
     */
    max: number;
    /**
     * Minimum machine count.
     */
    min: number;
    mode: "autoscale";
};
/**
 * Failure-domain policy selected for a compute pool.
 */
export type SyncListResponseFailureDomains1 = {
    /**
     * Concrete provider domains selected during setup.
     *
     * @remarks
     * Empty delegates deterministic selection to the provider setup implementation.
     */
    selectedFailureDomains?: Array<string> | undefined;
    /**
     * Number of distinct failure domains across which new stateful replicas may be spread.
     */
    spread: number;
};
export type SyncListResponseFailureDomainsUnion1 = SyncListResponseFailureDomains1 | any;
export type SyncListResponsePoolsFixed = {
    failureDomains?: SyncListResponseFailureDomains1 | any | null | undefined;
    /**
     * Provider machine type selected for this deployment.
     */
    machine?: string | null | undefined;
    /**
     * Number of machines to run.
     */
    machines: number;
    mode: "fixed";
};
/**
 * User-selected deployment settings for one compute pool.
 */
export type SyncListResponsePoolsUnion = SyncListResponsePoolsFixed | SyncListResponsePoolsAutoscale;
/**
 * Deployment-time compute choices for Alien-managed compute pools.
 *
 * @remarks
 *
 * Application source declares portable pool requirements. This settings
 * object stores the concrete choices made for one deployment, such as the
 * provider machine type and selected machine counts.
 */
export type SyncListResponseCompute = {
    /**
     * Selected compute choices keyed by pool ID.
     */
    pools?: {
        [k: string]: SyncListResponsePoolsFixed | SyncListResponsePoolsAutoscale;
    } | undefined;
};
export type SyncListResponseComputeUnion = SyncListResponseCompute | any;
/**
 * Deployment model: how updates are delivered to the remote environment.
 */
export 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 | any;
export type SyncListResponseAzureStackSettings = {
    keyVaultCertificateId: string;
    keyVaultResourceId?: string | null | undefined;
};
export type SyncListResponseAzureUnion = SyncListResponseAzureStackSettings | any;
export type SyncListResponseGcpStackSettings = {
    certificateName: string;
};
export type SyncListResponseGcpUnion = SyncListResponseGcpStackSettings | any;
/**
 * Namespace-scoped Kubernetes TLS Secret reference.
 */
export type SyncListResponseTlsSecretRef = {
    /**
     * Secret namespace. Defaults to the release namespace when omitted.
     */
    namespace?: string | null | undefined;
    /**
     * Secret name.
     */
    secretName: string;
};
export type SyncListResponseDomainsKubernetes = {
    /**
     * Namespace-scoped Kubernetes TLS Secret reference.
     */
    tlsSecretRef: SyncListResponseTlsSecretRef;
};
export type SyncListResponseDomainsKubernetesUnion = SyncListResponseDomainsKubernetes | any;
/**
 * Platform-specific certificate references for custom domains.
 */
export type SyncListResponseDomainsCertificate = {
    aws?: SyncListResponseAws | any | null | undefined;
    azure?: SyncListResponseAzureStackSettings | any | null | undefined;
    gcp?: SyncListResponseGcpStackSettings | any | null | undefined;
    kubernetes?: SyncListResponseDomainsKubernetes | any | null | undefined;
};
/**
 * Custom domain configuration for a single resource.
 */
export type SyncListResponseCustomDomains = {
    /**
     * Platform-specific certificate references for custom domains.
     */
    certificate: SyncListResponseDomainsCertificate;
    /**
     * Fully qualified domain name to use.
     */
    domain: string;
};
export 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 | any;
/**
 * Domain configuration for the stack.
 *
 * @remarks
 *
 * When `custom_domains` is set, the specified resources use customer-provided
 * domains and certificates. Otherwise, Alien auto-generates domains.
 */
export type SyncListResponseDomains = {
    /**
     * Custom domain configuration per resource ID.
     */
    customDomains?: {
        [k: string]: SyncListResponseCustomDomains;
    } | null | undefined;
    publicEndpointTarget?: SyncListResponsePublicEndpointTargetLoadBalancer | SyncListResponsePublicEndpointTargetMachineAddresses | any | null | undefined;
};
export type SyncListResponseDomainsUnion = SyncListResponseDomains | any;
/**
 * External bindings for pre-existing infrastructure.
 *
 * @remarks
 * Allows using existing resources (MinIO, Redis, shared Container Apps
 * Environment, etc.) instead of having Alien provision them.
 * Required for Kubernetes platform, optional for cloud platforms.
 */
export type SyncListResponseExternalBindings = {};
/**
 * How heartbeat health checks are handled.
 */
export 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 | any;
/**
 * 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 | any | null | undefined;
    /**
     * Namespace where the Alien chart and application resources run.
     */
    namespace?: string | null | undefined;
    /**
     * Ownership model for the Kubernetes cluster.
     */
    ownership: SyncListResponseOwnership;
};
export type SyncListResponseClusterUnion = SyncListResponseCluster | any;
export type SyncListResponseCertificateNone2 = {
    mode: "none";
};
export type SyncListResponseCertificateManagedTLSSecret2 = {
    mode: "managedTlsSecret";
    /**
     * Secret name template. Runtime may substitute resource/deployment tokens.
     */
    secretNameTemplate: string;
};
export type SyncListResponseCertificateAwsAcmArn2 = {
    /**
     * Existing ACM certificate ARN.
     */
    certificateArn: string;
    mode: "awsAcmArn";
};
export type SyncListResponseCertificateManagedAcmImport2 = {
    mode: "managedAcmImport";
    /**
     * ACM region. Defaults to the deployment region when omitted.
     */
    region?: string | null | undefined;
    /**
     * Tags applied to runtime-imported ACM certificates.
     */
    tags?: {
        [k: string]: string;
    } | undefined;
};
/**
 * Namespace-scoped Kubernetes TLS Secret reference.
 */
export type SyncListResponseCertificateTLSSecretRef2 = {
    /**
     * Secret namespace. Defaults to the release namespace when omitted.
     */
    namespace?: string | null | undefined;
    /**
     * Secret name.
     */
    secretName: string;
    mode: "tlsSecretRef";
};
/**
 * Certificate publication or reference mode for Kubernetes public endpoints.
 */
export type SyncListResponseCertificateUnion2 = SyncListResponseCertificateTLSSecretRef2 | SyncListResponseCertificateManagedAcmImport2 | SyncListResponseCertificateAwsAcmArn2 | SyncListResponseCertificateManagedTLSSecret2 | SyncListResponseCertificateNone2;
export 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 | any;
/**
 * Shared Gateway API route profile values.
 */
export type SyncListResponseRouteGateway2 = {
    /**
     * Annotations applied to route objects.
     */
    annotations?: {
        [k: string]: string;
    } | undefined;
    /**
     * Route controller identifier, for example a cloud Gateway controller.
     */
    controller?: string | null | undefined;
    /**
     * GatewayClass selected for generated Gateways.
     */
    gatewayClassName: string;
    /**
     * Labels applied to route objects.
     */
    labels?: {
        [k: string]: string;
    } | undefined;
    /**
     * Listener port, usually 443.
     */
    listenerPort: number;
    provider?: SyncListResponseProviderAwsAlb4 | SyncListResponseProviderAzureApplicationGatewayForContainers4 | SyncListResponseProviderGkeGateway4 | any | null | undefined;
    routeApi: "gateway";
};
export 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 | any;
/**
 * Shared Ingress route profile values.
 */
export type SyncListResponseRouteIngress2 = {
    /**
     * Annotations applied to route objects.
     */
    annotations?: {
        [k: string]: string;
    } | undefined;
    /**
     * Route controller identifier, for example `eks.amazonaws.com/alb`.
     */
    controller?: string | null | undefined;
    /**
     * `spec.ingressClassName` for generated Ingresses.
     */
    ingressClassName: string;
    /**
     * Labels applied to route objects.
     */
    labels?: {
        [k: string]: string;
    } | undefined;
    provider?: SyncListResponseProviderAwsAlb3 | SyncListResponseProviderAzureApplicationGatewayForContainers3 | SyncListResponseProviderGkeGateway3 | any | null | undefined;
    routeApi: "ingress";
};
/**
 * Kubernetes route API selected for public endpoints.
 */
export type SyncListResponseRouteUnion2 = SyncListResponseRouteIngress2 | SyncListResponseRouteGateway2;
export type SyncListResponseExposureCustom = {
    /**
     * Certificate publication or reference mode for Kubernetes public endpoints.
     */
    certificate: SyncListResponseCertificateTLSSecretRef2 | SyncListResponseCertificateManagedAcmImport2 | SyncListResponseCertificateAwsAcmArn2 | SyncListResponseCertificateManagedTLSSecret2 | SyncListResponseCertificateNone2;
    /**
     * Hostname routed by the Kubernetes public endpoint.
     */
    domain: string;
    mode: SyncListResponseModeCustom;
    /**
     * Kubernetes route API selected for public endpoints.
     */
    route: SyncListResponseRouteIngress2 | SyncListResponseRouteGateway2;
};
export type SyncListResponseCertificateNone1 = {
    mode: "none";
};
export type SyncListResponseCertificateManagedTLSSecret1 = {
    mode: "managedTlsSecret";
    /**
     * Secret name template. Runtime may substitute resource/deployment tokens.
     */
    secretNameTemplate: string;
};
export type SyncListResponseCertificateAwsAcmArn1 = {
    /**
     * Existing ACM certificate ARN.
     */
    certificateArn: string;
    mode: "awsAcmArn";
};
export type SyncListResponseCertificateManagedAcmImport1 = {
    mode: "managedAcmImport";
    /**
     * ACM region. Defaults to the deployment region when omitted.
     */
    region?: string | null | undefined;
    /**
     * Tags applied to runtime-imported ACM certificates.
     */
    tags?: {
        [k: string]: string;
    } | undefined;
};
/**
 * Namespace-scoped Kubernetes TLS Secret reference.
 */
export type SyncListResponseCertificateTLSSecretRef1 = {
    /**
     * Secret namespace. Defaults to the release namespace when omitted.
     */
    namespace?: string | null | undefined;
    /**
     * Secret name.
     */
    secretName: string;
    mode: "tlsSecretRef";
};
/**
 * Certificate publication or reference mode for Kubernetes public endpoints.
 */
export type SyncListResponseCertificateUnion1 = SyncListResponseCertificateTLSSecretRef1 | SyncListResponseCertificateManagedAcmImport1 | SyncListResponseCertificateAwsAcmArn1 | SyncListResponseCertificateManagedTLSSecret1 | SyncListResponseCertificateNone1;
export 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 | any;
/**
 * Shared Gateway API route profile values.
 */
export type SyncListResponseRouteGateway1 = {
    /**
     * Annotations applied to route objects.
     */
    annotations?: {
        [k: string]: string;
    } | undefined;
    /**
     * Route controller identifier, for example a cloud Gateway controller.
     */
    controller?: string | null | undefined;
    /**
     * GatewayClass selected for generated Gateways.
     */
    gatewayClassName: string;
    /**
     * Labels applied to route objects.
     */
    labels?: {
        [k: string]: string;
    } | undefined;
    /**
     * Listener port, usually 443.
     */
    listenerPort: number;
    provider?: SyncListResponseProviderAwsAlb2 | SyncListResponseProviderAzureApplicationGatewayForContainers2 | SyncListResponseProviderGkeGateway2 | any | null | undefined;
    routeApi: "gateway";
};
export 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 | any;
/**
 * Shared Ingress route profile values.
 */
export type SyncListResponseRouteIngress1 = {
    /**
     * Annotations applied to route objects.
     */
    annotations?: {
        [k: string]: string;
    } | undefined;
    /**
     * Route controller identifier, for example `eks.amazonaws.com/alb`.
     */
    controller?: string | null | undefined;
    /**
     * `spec.ingressClassName` for generated Ingresses.
     */
    ingressClassName: string;
    /**
     * Labels applied to route objects.
     */
    labels?: {
        [k: string]: string;
    } | undefined;
    provider?: SyncListResponseProviderAwsAlb1 | SyncListResponseProviderAzureApplicationGatewayForContainers1 | SyncListResponseProviderGkeGateway1 | any | null | undefined;
    routeApi: "ingress";
};
/**
 * Kubernetes route API selected for public endpoints.
 */
export type SyncListResponseRouteUnion1 = SyncListResponseRouteIngress1 | SyncListResponseRouteGateway1;
export type SyncListResponseExposureGenerated = {
    /**
     * Certificate publication or reference mode for Kubernetes public endpoints.
     */
    certificate: SyncListResponseCertificateTLSSecretRef1 | SyncListResponseCertificateManagedAcmImport1 | SyncListResponseCertificateAwsAcmArn1 | SyncListResponseCertificateManagedTLSSecret1 | SyncListResponseCertificateNone1;
    mode: SyncListResponseModeGenerated;
    /**
     * Kubernetes route API selected for public endpoints.
     */
    route: SyncListResponseRouteIngress1 | SyncListResponseRouteGateway1;
};
export declare const SyncListResponseModeDisabled: {
    readonly Disabled: "disabled";
};
export type SyncListResponseModeDisabled = ClosedEnum<typeof SyncListResponseModeDisabled>;
export type SyncListResponseExposureDisabled = {
    mode: SyncListResponseModeDisabled;
};
export type SyncListResponseExposureUnion = SyncListResponseExposureCustom | SyncListResponseExposureGenerated | SyncListResponseExposureDisabled | any;
/**
 * Kubernetes runtime substrate configuration.
 *
 * @remarks
 *
 * This controls how setup chooses the cluster backing `Platform::Kubernetes`
 * deployments. When omitted, cloud-backed Kubernetes deployments default to a
 * managed cluster and generic/on-prem Kubernetes defaults to an external
 * cluster.
 */
export type SyncListResponseKubernetes = {
    cluster?: SyncListResponseCluster | any | null | undefined;
    exposure?: SyncListResponseExposureCustom | SyncListResponseExposureGenerated | SyncListResponseExposureDisabled | any | null | undefined;
};
export type SyncListResponseKubernetesUnion = SyncListResponseKubernetes | any;
export 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 | any;
/**
 * 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 | any | null | undefined;
    /**
     * Deployment model: how updates are delivered to the remote environment.
     */
    deploymentModel?: SyncListResponseDeploymentModel | undefined;
    domains?: SyncListResponseDomains | any | null | undefined;
    /**
     * External bindings for pre-existing infrastructure.
     *
     * @remarks
     * Allows using existing resources (MinIO, Redis, shared Container Apps
     * Environment, etc.) instead of having Alien provision them.
     * Required for Kubernetes platform, optional for cloud platforms.
     */
    externalBindings?: SyncListResponseExternalBindings | null | undefined;
    /**
     * How heartbeat health checks are handled.
     */
    heartbeats?: SyncListResponseHeartbeats | undefined;
    kubernetes?: SyncListResponseKubernetes | any | null | undefined;
    network?: SyncListResponseNetworkByoVpcAws | SyncListResponseNetworkByoVpcGcp | SyncListResponseNetworkByoVnetAzure | SyncListResponseNetworkUseDefault | SyncListResponseNetworkCreate | any | null | undefined;
    /**
     * Exact externally managed endpoint URLs, keyed by resource ID and endpoint name.
     *
     * @remarks
     *
     * This is intended for adopted Machines deployments whose DNS and certificates remain
     * customer-owned. The platform passes these URLs to the runtime without creating or
     * replacing DNS records or certificates.
     */
    publicEndpoints?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * How telemetry (logs, metrics, traces) is handled.
     */
    telemetry?: SyncListResponseTelemetry | undefined;
    /**
     * How updates are delivered to the deployment.
     */
    updates?: SyncListResponseUpdates | undefined;
};
/**
 * Represents the target cloud platform.
 */
export 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 | any;
/**
 * Reference to a resource by its stable id and resource type.
 */
export type SyncListResponseStackStateDependency = {
    id: string;
    /**
     * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
     */
    type: string;
};
/**
 * Canonical error container that provides a structured way to represent errors
 *
 * @remarks
 * with rich metadata including error codes, human-readable messages, context,
 * and chaining capabilities for error propagation.
 *
 * This struct is designed to be both machine-readable and user-friendly,
 * supporting serialization for API responses and detailed error reporting
 * in distributed systems.
 */
export type SyncListResponseErrorStackState = {
    /**
     * A unique identifier for the type of error.
     *
     * @remarks
     *
     * This should be a short, machine-readable string that can be used
     * by clients to programmatically handle different error types.
     * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
     */
    code: string;
    /**
     * Additional diagnostic information about the error context.
     *
     * @remarks
     *
     * This optional field can contain structured data providing more details
     * about the error, such as validation errors, request parameters that
     * caused the issue, or other relevant context information.
     */
    context?: any | null | undefined;
    /**
     * Optional human-facing remediation hint.
     */
    hint?: string | null | undefined;
    /**
     * HTTP status code for this error.
     *
     * @remarks
     *
     * Used when converting the error to an HTTP response. If None, falls back to
     * the error type's default status code or 500.
     */
    httpStatusCode?: number | null | undefined;
    /**
     * Indicates if this is an internal error that should not be exposed to users.
     *
     * @remarks
     *
     * When `true`, this error contains sensitive information or implementation
     * details that should not be shown to end-users. Such errors should be
     * logged for debugging but replaced with generic error messages in responses.
     */
    internal: boolean;
    /**
     * Human-readable error message.
     *
     * @remarks
     *
     * This message should be clear and actionable for developers or end-users,
     * providing context about what went wrong and potentially how to fix it.
     */
    message: string;
    /**
     * Indicates whether the operation that caused the error should be retried.
     *
     * @remarks
     *
     * When `true`, the error is transient and the operation might succeed
     * if attempted again. When `false`, retrying the same operation is
     * unlikely to succeed without changes.
     */
    retryable: boolean;
    /**
     * The underlying error that caused this error, creating an error chain.
     *
     * @remarks
     *
     * This allows for proper error propagation and debugging by maintaining
     * the full context of how an error occurred through multiple layers
     * of an application.
     */
    source?: any | null | undefined;
};
export type SyncListResponseErrorUnion = SyncListResponseErrorStackState | any;
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export 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 | any;
/**
 * Resource outputs that can hold output data for any resource type in the Alien system. All resource outputs share a common 'type' field with additional type-specific output properties.
 */
export type SyncListResponseOutputs = {
    /**
     * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
     */
    type: string;
    additionalProperties?: {
        [k: string]: any | null;
    } | undefined;
};
export type SyncListResponseOutputsUnion = SyncListResponseOutputs | any;
/**
 * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
 */
export type SyncListResponsePreviousConfig = {
    /**
     * The unique identifier for this specific resource instance. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
     */
    id: string;
    /**
     * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
     */
    type: string;
    additionalProperties?: {
        [k: string]: any | null;
    } | undefined;
};
export type SyncListResponsePreviousConfigUnion = SyncListResponsePreviousConfig | any;
/**
 * Represents the high-level status of a resource during its lifecycle.
 */
export 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 | any | null | undefined;
    /**
     * Complete list of dependencies for this resource, including infrastructure dependencies.
     *
     * @remarks
     * This preserves the full dependency information from the stack definition.
     */
    dependencies?: Array<SyncListResponseStackStateDependency> | undefined;
    error?: SyncListResponseErrorStackState | any | null | undefined;
    /**
     * Stores the controller state that failed, used for manual retry operations.
     *
     * @remarks
     * This allows resuming from the exact point where the failure occurred.
     * Stored as JSON to make the struct serializable and movable to alien-core.
     */
    lastFailedState?: any | null | undefined;
    lifecycle?: SyncListResponseLifecycleStackStateEnum | any | null | undefined;
    outputs?: SyncListResponseOutputs | any | null | undefined;
    previousConfig?: SyncListResponsePreviousConfig | any | null | undefined;
    /**
     * Binding parameters for remote access.
     *
     * @remarks
     * Only populated when the resource has `remote_access: true` in its ResourceEntry.
     * This is the JSON serialization of the binding configuration (e.g., StorageBinding, VaultBinding).
     * Populated by controllers during provisioning using get_binding_params().
     */
    remoteBindingParams?: any | null | undefined;
    /**
     * Tracks consecutive retry attempts for the current state transition.
     */
    retryAttempt?: number | undefined;
    /**
     * Represents the high-level status of a resource during its lifecycle.
     */
    status: SyncListResponseStackStateStatus;
    /**
     * The high-level type of the resource (e.g., Worker::RESOURCE_TYPE, Storage::RESOURCE_TYPE).
     */
    type: string;
};
/**
 * State of infrastructure components managed by this deployment
 */
export type SyncListResponseStackState = {
    /**
     * Represents the target cloud platform.
     */
    platform: SyncListResponseStackStatePlatform;
    /**
     * A prefix used for resource naming to ensure uniqueness across deployments.
     */
    resourcePrefix: string;
    /**
     * The state of individual resources, keyed by resource ID.
     */
    resources: {
        [k: string]: SyncListResponseStackStateResources;
    };
};
/**
 * Actor that owns structural work during the initial setup phase.
 */
export 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>;
};
export declare const SyncListResponsePendingPreparedStackTypeBoolean: {
    readonly Boolean: "boolean";
};
export type SyncListResponsePendingPreparedStackTypeBoolean = ClosedEnum<typeof SyncListResponsePendingPreparedStackTypeBoolean>;
export type SyncListResponsePendingPreparedStackDefaultBoolean = {
    type: SyncListResponsePendingPreparedStackTypeBoolean;
    /**
     * Boolean default.
     */
    value: boolean;
};
export declare const SyncListResponsePendingPreparedStackTypeNumber: {
    readonly Number: "number";
};
export type SyncListResponsePendingPreparedStackTypeNumber = ClosedEnum<typeof SyncListResponsePendingPreparedStackTypeNumber>;
export type SyncListResponsePendingPreparedStackDefaultNumber = {
    type: SyncListResponsePendingPreparedStackTypeNumber;
    /**
     * Number default.
     */
    value: string;
};
export declare const SyncListResponsePendingPreparedStackTypeString: {
    readonly String: "string";
};
export type SyncListResponsePendingPreparedStackTypeString = ClosedEnum<typeof SyncListResponsePendingPreparedStackTypeString>;
export type SyncListResponsePendingPreparedStackDefaultString = {
    type: SyncListResponsePendingPreparedStackTypeString;
    /**
     * String default.
     */
    value: string;
};
export type SyncListResponsePendingPreparedStackDefaultUnion = SyncListResponsePendingPreparedStackDefaultString | SyncListResponsePendingPreparedStackDefaultNumber | SyncListResponsePendingPreparedStackDefaultBoolean | SyncListResponsePendingPreparedStackDefaultStringList | any;
/**
 * Environment variable handling for a stack input mapping.
 */
export declare const SyncListResponsePendingPreparedStackTypeEnvEnum: {
    readonly Plain: "plain";
    readonly Secret: "secret";
};
/**
 * Environment variable handling for a stack input mapping.
 */
export type SyncListResponsePendingPreparedStackTypeEnvEnum = ClosedEnum<typeof SyncListResponsePendingPreparedStackTypeEnvEnum>;
export type SyncListResponsePendingPreparedStackTypeUnion = SyncListResponsePendingPreparedStackTypeEnvEnum | any;
/**
 * How a resolved stack input is injected into runtime environment variables.
 */
export type SyncListResponsePendingPreparedStackEnv = {
    /**
     * Environment variable name.
     */
    name: string;
    /**
     * Target resource IDs or patterns. None means every env-capable resource.
     */
    targetResources?: Array<string> | null | undefined;
    type?: SyncListResponsePendingPreparedStackTypeEnvEnum | any | null | undefined;
};
/**
 * Primitive stack input kind.
 */
export declare const SyncListResponsePendingPreparedStackKind: {
    readonly String: "string";
    readonly Secret: "secret";
    readonly Number: "number";
    readonly Integer: "integer";
    readonly Boolean: "boolean";
    readonly Enum: "enum";
    readonly StringList: "stringList";
};
/**
 * Primitive stack input kind.
 */
export type SyncListResponsePendingPreparedStackKind = ClosedEnum<typeof SyncListResponsePendingPreparedStackKind>;
/**
 * Represents the target cloud platform.
 */
export declare const SyncListResponsePendingPreparedStackPlatform: {
    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 SyncListResponsePendingPreparedStackPlatform = ClosedEnum<typeof SyncListResponsePendingPreparedStackPlatform>;
/**
 * Who can provide a stack input value.
 */
export declare const SyncListResponsePendingPreparedStackProvidedBy: {
    readonly Developer: "developer";
    readonly Deployer: "deployer";
};
/**
 * Who can provide a stack input value.
 */
export type SyncListResponsePendingPreparedStackProvidedBy = ClosedEnum<typeof SyncListResponsePendingPreparedStackProvidedBy>;
/**
 * Portable stack input validation constraints.
 */
export type SyncListResponsePendingPreparedStackValidation = {
    /**
     * Semantic format hint such as url.
     */
    format?: string | null | undefined;
    /**
     * Maximum number.
     */
    max?: string | null | undefined;
    /**
     * Maximum string-list items.
     */
    maxItems?: number | null | undefined;
    /**
     * Maximum string length.
     */
    maxLength?: number | null | undefined;
    /**
     * Minimum number.
     */
    min?: string | null | undefined;
    /**
     * Minimum string-list items.
     */
    minItems?: number | null | undefined;
    /**
     * Minimum string length.
     */
    minLength?: number | null | undefined;
    /**
     * Portable whole-value regex pattern.
     */
    pattern?: string | null | undefined;
    /**
     * Allowed string enum values.
     */
    values?: Array<string> | null | undefined;
};
export type SyncListResponsePendingPreparedStackValidationUnion = SyncListResponsePendingPreparedStackValidation | any;
/**
 * Stack input definition serialized into a release stack.
 */
export type SyncListResponsePendingPreparedStackInput = {
    default?: SyncListResponsePendingPreparedStackDefaultString | SyncListResponsePendingPreparedStackDefaultNumber | SyncListResponsePendingPreparedStackDefaultBoolean | SyncListResponsePendingPreparedStackDefaultStringList | any | null | undefined;
    /**
     * Human-facing helper text.
     */
    description: string;
    /**
     * Runtime env-var mappings for v1 input resolution.
     */
    env?: Array<SyncListResponsePendingPreparedStackEnv> | undefined;
    /**
     * Stable input ID used by CLI/API calls.
     */
    id: string;
    /**
     * Primitive stack input kind.
     */
    kind: SyncListResponsePendingPreparedStackKind;
    /**
     * Human-facing field label.
     */
    label: string;
    /**
     * Example placeholder shown in UI.
     */
    placeholder?: string | null | undefined;
    /**
     * Platforms where this input applies.
     */
    platforms?: Array<SyncListResponsePendingPreparedStackPlatform> | null | undefined;
    /**
     * Who can provide this value.
     */
    providedBy: Array<SyncListResponsePendingPreparedStackProvidedBy>;
    /**
     * Whether a resolved value is required before deployment can proceed.
     */
    required: boolean;
    validation?: SyncListResponsePendingPreparedStackValidation | any | null | undefined;
};
export declare const SyncListResponsePendingPreparedStackManagementEnum: {
    readonly Auto: "auto";
};
export type SyncListResponsePendingPreparedStackManagementEnum = ClosedEnum<typeof SyncListResponsePendingPreparedStackManagementEnum>;
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePendingPreparedStackOverrideAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePendingPreparedStackOverrideAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackOverrideAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: SyncListResponsePendingPreparedStackOverrideAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: SyncListResponsePendingPreparedStackOverrideAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const SyncListResponsePendingPreparedStackOverrideEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type SyncListResponsePendingPreparedStackOverrideEffect = ClosedEnum<typeof SyncListResponsePendingPreparedStackOverrideEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackOverrideAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type SyncListResponsePendingPreparedStackOverrideAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePendingPreparedStackOverrideAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: SyncListResponsePendingPreparedStackOverrideEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePendingPreparedStackOverrideAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePendingPreparedStackOverrideAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePendingPreparedStackOverrideAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackOverrideAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: SyncListResponsePendingPreparedStackOverrideAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: SyncListResponsePendingPreparedStackOverrideAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackOverrideAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type SyncListResponsePendingPreparedStackOverrideAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePendingPreparedStackOverrideAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePendingPreparedStackOverrideAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePendingPreparedStackOverrideConditionResource = {
    expression: string;
    title: string;
};
export type SyncListResponsePendingPreparedStackOverrideResourceConditionUnion = SyncListResponsePendingPreparedStackOverrideConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePendingPreparedStackOverrideGcpResource = {
    condition?: SyncListResponsePendingPreparedStackOverrideConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePendingPreparedStackOverrideConditionStack = {
    expression: string;
    title: string;
};
export type SyncListResponsePendingPreparedStackOverrideStackConditionUnion = SyncListResponsePendingPreparedStackOverrideConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePendingPreparedStackOverrideGcpStack = {
    condition?: SyncListResponsePendingPreparedStackOverrideConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackOverrideGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: SyncListResponsePendingPreparedStackOverrideGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: SyncListResponsePendingPreparedStackOverrideGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackOverrideGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type SyncListResponsePendingPreparedStackOverrideGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePendingPreparedStackOverrideGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePendingPreparedStackOverrideGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePendingPreparedStackOverridePlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<SyncListResponsePendingPreparedStackOverrideAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<SyncListResponsePendingPreparedStackOverrideAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<SyncListResponsePendingPreparedStackOverrideGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePendingPreparedStackOverride = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: SyncListResponsePendingPreparedStackOverridePlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type SyncListResponsePendingPreparedStackOverrideUnion = SyncListResponsePendingPreparedStackOverride | string;
export type SyncListResponsePendingPreparedStackManagement2 = {
    /**
     * Permission profile that maps resources to permission sets
     *
     * @remarks
     * Key can be "*" for all resources or resource name for specific resource
     */
    override: {
        [k: string]: Array<SyncListResponsePendingPreparedStackOverride | string>;
    };
};
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePendingPreparedStackExtendAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePendingPreparedStackExtendAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackExtendAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: SyncListResponsePendingPreparedStackExtendAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: SyncListResponsePendingPreparedStackExtendAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const SyncListResponsePendingPreparedStackExtendEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type SyncListResponsePendingPreparedStackExtendEffect = ClosedEnum<typeof SyncListResponsePendingPreparedStackExtendEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackExtendAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type SyncListResponsePendingPreparedStackExtendAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePendingPreparedStackExtendAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: SyncListResponsePendingPreparedStackExtendEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePendingPreparedStackExtendAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePendingPreparedStackExtendAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePendingPreparedStackExtendAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackExtendAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: SyncListResponsePendingPreparedStackExtendAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: SyncListResponsePendingPreparedStackExtendAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackExtendAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type SyncListResponsePendingPreparedStackExtendAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePendingPreparedStackExtendAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePendingPreparedStackExtendAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePendingPreparedStackExtendConditionResource = {
    expression: string;
    title: string;
};
export type SyncListResponsePendingPreparedStackExtendResourceConditionUnion = SyncListResponsePendingPreparedStackExtendConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePendingPreparedStackExtendGcpResource = {
    condition?: SyncListResponsePendingPreparedStackExtendConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePendingPreparedStackExtendConditionStack = {
    expression: string;
    title: string;
};
export type SyncListResponsePendingPreparedStackExtendStackConditionUnion = SyncListResponsePendingPreparedStackExtendConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePendingPreparedStackExtendGcpStack = {
    condition?: SyncListResponsePendingPreparedStackExtendConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackExtendGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: SyncListResponsePendingPreparedStackExtendGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: SyncListResponsePendingPreparedStackExtendGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackExtendGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type SyncListResponsePendingPreparedStackExtendGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePendingPreparedStackExtendGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePendingPreparedStackExtendGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePendingPreparedStackExtendPlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<SyncListResponsePendingPreparedStackExtendAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<SyncListResponsePendingPreparedStackExtendAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<SyncListResponsePendingPreparedStackExtendGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePendingPreparedStackExtend = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: SyncListResponsePendingPreparedStackExtendPlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type SyncListResponsePendingPreparedStackExtendUnion = SyncListResponsePendingPreparedStackExtend | string;
export type SyncListResponsePendingPreparedStackManagement1 = {
    /**
     * Permission profile that maps resources to permission sets
     *
     * @remarks
     * Key can be "*" for all resources or resource name for specific resource
     */
    extend: {
        [k: string]: Array<SyncListResponsePendingPreparedStackExtend | string>;
    };
};
/**
 * Management permissions configuration for stack management access
 */
export type SyncListResponsePendingPreparedStackManagementUnion = SyncListResponsePendingPreparedStackManagement1 | SyncListResponsePendingPreparedStackManagement2 | SyncListResponsePendingPreparedStackManagementEnum;
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePendingPreparedStackProfileAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePendingPreparedStackProfileAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackProfileAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: SyncListResponsePendingPreparedStackProfileAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: SyncListResponsePendingPreparedStackProfileAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const SyncListResponsePendingPreparedStackProfileEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type SyncListResponsePendingPreparedStackProfileEffect = ClosedEnum<typeof SyncListResponsePendingPreparedStackProfileEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackProfileAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type SyncListResponsePendingPreparedStackProfileAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePendingPreparedStackProfileAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: SyncListResponsePendingPreparedStackProfileEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePendingPreparedStackProfileAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePendingPreparedStackProfileAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePendingPreparedStackProfileAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackProfileAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: SyncListResponsePendingPreparedStackProfileAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: SyncListResponsePendingPreparedStackProfileAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackProfileAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type SyncListResponsePendingPreparedStackProfileAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePendingPreparedStackProfileAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePendingPreparedStackProfileAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePendingPreparedStackProfileConditionResource = {
    expression: string;
    title: string;
};
export type SyncListResponsePendingPreparedStackProfileResourceConditionUnion = SyncListResponsePendingPreparedStackProfileConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePendingPreparedStackProfileGcpResource = {
    condition?: SyncListResponsePendingPreparedStackProfileConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePendingPreparedStackProfileConditionStack = {
    expression: string;
    title: string;
};
export type SyncListResponsePendingPreparedStackProfileStackConditionUnion = SyncListResponsePendingPreparedStackProfileConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePendingPreparedStackProfileGcpStack = {
    condition?: SyncListResponsePendingPreparedStackProfileConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePendingPreparedStackProfileGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: SyncListResponsePendingPreparedStackProfileGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: SyncListResponsePendingPreparedStackProfileGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePendingPreparedStackProfileGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type SyncListResponsePendingPreparedStackProfileGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePendingPreparedStackProfileGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePendingPreparedStackProfileGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePendingPreparedStackProfilePlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<SyncListResponsePendingPreparedStackProfileAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<SyncListResponsePendingPreparedStackProfileAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<SyncListResponsePendingPreparedStackProfileGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePendingPreparedStackProfile = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: SyncListResponsePendingPreparedStackProfilePlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type SyncListResponsePendingPreparedStackProfileUnion = SyncListResponsePendingPreparedStackProfile | string;
/**
 * Combined permissions configuration that contains both profiles and management
 */
export type SyncListResponsePendingPreparedStackPermissions = {
    /**
     * Management permissions configuration for stack management access
     */
    management?: SyncListResponsePendingPreparedStackManagement1 | SyncListResponsePendingPreparedStackManagement2 | SyncListResponsePendingPreparedStackManagementEnum | undefined;
    /**
     * Permission profiles that define access control for compute services
     *
     * @remarks
     * Key is the profile name, value is the permission configuration
     */
    profiles: {
        [k: string]: {
            [k: string]: Array<SyncListResponsePendingPreparedStackProfile | string>;
        };
    };
};
/**
 * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
 */
export type SyncListResponsePendingPreparedStackConfig = {
    /**
     * The unique identifier for this specific resource instance. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
     */
    id: string;
    /**
     * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
     */
    type: string;
    additionalProperties?: {
        [k: string]: any | null;
    } | undefined;
};
/**
 * Reference to a resource by its stable id and resource type.
 */
export type SyncListResponsePendingPreparedStackDependency = {
    id: string;
    /**
     * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
     */
    type: string;
};
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export declare const SyncListResponsePendingPreparedStackLifecycle: {
    readonly Frozen: "frozen";
    readonly Live: "live";
};
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export type SyncListResponsePendingPreparedStackLifecycle = ClosedEnum<typeof SyncListResponsePendingPreparedStackLifecycle>;
export type SyncListResponsePendingPreparedStackResources = {
    /**
     * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
     */
    config: SyncListResponsePendingPreparedStackConfig;
    /**
     * Additional dependencies for this resource beyond those defined in the resource itself.
     *
     * @remarks
     * The total dependencies are: resource.get_dependencies() + this list
     */
    dependencies: Array<SyncListResponsePendingPreparedStackDependency>;
    /**
     * Id of the boolean stack input that decides whether this resource is
     *
     * @remarks
     * created at all. `None` means always create it.
     *
     * Set by `.enabled(input)` in the SDK. Setup emitters render the resource
     * conditionally on the matching template variable, so a deployer who says no
     * never gets the resource, its outputs, or anything derived from it.
     */
    enabledWhen?: string | null | undefined;
    /**
     * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
     */
    lifecycle: SyncListResponsePendingPreparedStackLifecycle;
    /**
     * Enable remote bindings for this resource (BYOB use case).
     *
     * @remarks
     * When true, binding params are synced to StackState's `remote_binding_params`.
     * Default: false (prevents sensitive data in synced state).
     */
    remoteAccess?: boolean | undefined;
};
/**
 * Represents the target cloud platform.
 */
export declare const SyncListResponsePendingPreparedStackSupportedPlatform: {
    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 SyncListResponsePendingPreparedStackSupportedPlatform = ClosedEnum<typeof SyncListResponsePendingPreparedStackSupportedPlatform>;
/**
 * A bag of resources, unaware of any cloud.
 */
export type SyncListResponsePendingPreparedStack = {
    /**
     * Unique identifier for the stack
     */
    id: string;
    /**
     * Input definitions required before setup or deployment can proceed.
     */
    inputs?: Array<SyncListResponsePendingPreparedStackInput> | undefined;
    /**
     * Combined permissions configuration that contains both profiles and management
     */
    permissions?: SyncListResponsePendingPreparedStackPermissions | undefined;
    /**
     * Map of resource IDs to their configurations and lifecycle settings
     */
    resources: {
        [k: string]: SyncListResponsePendingPreparedStackResources;
    };
    /**
     * Which platforms this stack supports. When None, all platforms are supported.
     */
    supportedPlatforms?: Array<SyncListResponsePendingPreparedStackSupportedPlatform> | null | undefined;
};
export type SyncListResponsePendingPreparedStackUnion = SyncListResponsePendingPreparedStack | any;
export declare const SyncListResponsePreparedStackTypeStringList: {
    readonly StringList: "stringList";
};
export type SyncListResponsePreparedStackTypeStringList = ClosedEnum<typeof SyncListResponsePreparedStackTypeStringList>;
export type SyncListResponsePreparedStackDefaultStringList = {
    type: SyncListResponsePreparedStackTypeStringList;
    /**
     * String list default.
     */
    value: Array<string>;
};
export declare const SyncListResponsePreparedStackTypeBoolean: {
    readonly Boolean: "boolean";
};
export type SyncListResponsePreparedStackTypeBoolean = ClosedEnum<typeof SyncListResponsePreparedStackTypeBoolean>;
export type SyncListResponsePreparedStackDefaultBoolean = {
    type: SyncListResponsePreparedStackTypeBoolean;
    /**
     * Boolean default.
     */
    value: boolean;
};
export declare const SyncListResponsePreparedStackTypeNumber: {
    readonly Number: "number";
};
export type SyncListResponsePreparedStackTypeNumber = ClosedEnum<typeof SyncListResponsePreparedStackTypeNumber>;
export type SyncListResponsePreparedStackDefaultNumber = {
    type: SyncListResponsePreparedStackTypeNumber;
    /**
     * Number default.
     */
    value: string;
};
export declare const SyncListResponsePreparedStackTypeString: {
    readonly String: "string";
};
export type SyncListResponsePreparedStackTypeString = ClosedEnum<typeof SyncListResponsePreparedStackTypeString>;
export type SyncListResponsePreparedStackDefaultString = {
    type: SyncListResponsePreparedStackTypeString;
    /**
     * String default.
     */
    value: string;
};
export type SyncListResponsePreparedStackDefaultUnion = SyncListResponsePreparedStackDefaultString | SyncListResponsePreparedStackDefaultNumber | SyncListResponsePreparedStackDefaultBoolean | SyncListResponsePreparedStackDefaultStringList | any;
/**
 * Environment variable handling for a stack input mapping.
 */
export declare const SyncListResponsePreparedStackTypeEnvEnum: {
    readonly Plain: "plain";
    readonly Secret: "secret";
};
/**
 * Environment variable handling for a stack input mapping.
 */
export type SyncListResponsePreparedStackTypeEnvEnum = ClosedEnum<typeof SyncListResponsePreparedStackTypeEnvEnum>;
export type SyncListResponsePreparedStackTypeUnion = SyncListResponsePreparedStackTypeEnvEnum | any;
/**
 * How a resolved stack input is injected into runtime environment variables.
 */
export type SyncListResponsePreparedStackEnv = {
    /**
     * Environment variable name.
     */
    name: string;
    /**
     * Target resource IDs or patterns. None means every env-capable resource.
     */
    targetResources?: Array<string> | null | undefined;
    type?: SyncListResponsePreparedStackTypeEnvEnum | any | null | undefined;
};
/**
 * Primitive stack input kind.
 */
export declare const SyncListResponsePreparedStackKind: {
    readonly String: "string";
    readonly Secret: "secret";
    readonly Number: "number";
    readonly Integer: "integer";
    readonly Boolean: "boolean";
    readonly Enum: "enum";
    readonly StringList: "stringList";
};
/**
 * Primitive stack input kind.
 */
export type SyncListResponsePreparedStackKind = ClosedEnum<typeof SyncListResponsePreparedStackKind>;
/**
 * Represents the target cloud platform.
 */
export declare const SyncListResponsePreparedStackPlatform: {
    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 SyncListResponsePreparedStackPlatform = ClosedEnum<typeof SyncListResponsePreparedStackPlatform>;
/**
 * Who can provide a stack input value.
 */
export declare const SyncListResponsePreparedStackProvidedBy: {
    readonly Developer: "developer";
    readonly Deployer: "deployer";
};
/**
 * Who can provide a stack input value.
 */
export type SyncListResponsePreparedStackProvidedBy = ClosedEnum<typeof SyncListResponsePreparedStackProvidedBy>;
/**
 * Portable stack input validation constraints.
 */
export type SyncListResponsePreparedStackValidation = {
    /**
     * Semantic format hint such as url.
     */
    format?: string | null | undefined;
    /**
     * Maximum number.
     */
    max?: string | null | undefined;
    /**
     * Maximum string-list items.
     */
    maxItems?: number | null | undefined;
    /**
     * Maximum string length.
     */
    maxLength?: number | null | undefined;
    /**
     * Minimum number.
     */
    min?: string | null | undefined;
    /**
     * Minimum string-list items.
     */
    minItems?: number | null | undefined;
    /**
     * Minimum string length.
     */
    minLength?: number | null | undefined;
    /**
     * Portable whole-value regex pattern.
     */
    pattern?: string | null | undefined;
    /**
     * Allowed string enum values.
     */
    values?: Array<string> | null | undefined;
};
export type SyncListResponsePreparedStackValidationUnion = SyncListResponsePreparedStackValidation | any;
/**
 * Stack input definition serialized into a release stack.
 */
export type SyncListResponsePreparedStackInput = {
    default?: SyncListResponsePreparedStackDefaultString | SyncListResponsePreparedStackDefaultNumber | SyncListResponsePreparedStackDefaultBoolean | SyncListResponsePreparedStackDefaultStringList | any | null | undefined;
    /**
     * Human-facing helper text.
     */
    description: string;
    /**
     * Runtime env-var mappings for v1 input resolution.
     */
    env?: Array<SyncListResponsePreparedStackEnv> | undefined;
    /**
     * Stable input ID used by CLI/API calls.
     */
    id: string;
    /**
     * Primitive stack input kind.
     */
    kind: SyncListResponsePreparedStackKind;
    /**
     * Human-facing field label.
     */
    label: string;
    /**
     * Example placeholder shown in UI.
     */
    placeholder?: string | null | undefined;
    /**
     * Platforms where this input applies.
     */
    platforms?: Array<SyncListResponsePreparedStackPlatform> | null | undefined;
    /**
     * Who can provide this value.
     */
    providedBy: Array<SyncListResponsePreparedStackProvidedBy>;
    /**
     * Whether a resolved value is required before deployment can proceed.
     */
    required: boolean;
    validation?: SyncListResponsePreparedStackValidation | any | null | undefined;
};
export declare const SyncListResponsePreparedStackManagementEnum: {
    readonly Auto: "auto";
};
export type SyncListResponsePreparedStackManagementEnum = ClosedEnum<typeof SyncListResponsePreparedStackManagementEnum>;
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePreparedStackOverrideAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePreparedStackOverrideAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackOverrideAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: SyncListResponsePreparedStackOverrideAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: SyncListResponsePreparedStackOverrideAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const SyncListResponsePreparedStackOverrideEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type SyncListResponsePreparedStackOverrideEffect = ClosedEnum<typeof SyncListResponsePreparedStackOverrideEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackOverrideAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type SyncListResponsePreparedStackOverrideAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePreparedStackOverrideAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: SyncListResponsePreparedStackOverrideEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePreparedStackOverrideAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePreparedStackOverrideAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePreparedStackOverrideAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackOverrideAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: SyncListResponsePreparedStackOverrideAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: SyncListResponsePreparedStackOverrideAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackOverrideAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type SyncListResponsePreparedStackOverrideAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePreparedStackOverrideAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePreparedStackOverrideAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePreparedStackOverrideConditionResource = {
    expression: string;
    title: string;
};
export type SyncListResponsePreparedStackOverrideResourceConditionUnion = SyncListResponsePreparedStackOverrideConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePreparedStackOverrideGcpResource = {
    condition?: SyncListResponsePreparedStackOverrideConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePreparedStackOverrideConditionStack = {
    expression: string;
    title: string;
};
export type SyncListResponsePreparedStackOverrideStackConditionUnion = SyncListResponsePreparedStackOverrideConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePreparedStackOverrideGcpStack = {
    condition?: SyncListResponsePreparedStackOverrideConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackOverrideGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: SyncListResponsePreparedStackOverrideGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: SyncListResponsePreparedStackOverrideGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackOverrideGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type SyncListResponsePreparedStackOverrideGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePreparedStackOverrideGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePreparedStackOverrideGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePreparedStackOverridePlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<SyncListResponsePreparedStackOverrideAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<SyncListResponsePreparedStackOverrideAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<SyncListResponsePreparedStackOverrideGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePreparedStackOverride = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: SyncListResponsePreparedStackOverridePlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type SyncListResponsePreparedStackOverrideUnion = SyncListResponsePreparedStackOverride | string;
export type SyncListResponsePreparedStackManagement2 = {
    /**
     * Permission profile that maps resources to permission sets
     *
     * @remarks
     * Key can be "*" for all resources or resource name for specific resource
     */
    override: {
        [k: string]: Array<SyncListResponsePreparedStackOverride | string>;
    };
};
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePreparedStackExtendAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePreparedStackExtendAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackExtendAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: SyncListResponsePreparedStackExtendAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: SyncListResponsePreparedStackExtendAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const SyncListResponsePreparedStackExtendEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type SyncListResponsePreparedStackExtendEffect = ClosedEnum<typeof SyncListResponsePreparedStackExtendEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackExtendAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type SyncListResponsePreparedStackExtendAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePreparedStackExtendAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: SyncListResponsePreparedStackExtendEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePreparedStackExtendAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePreparedStackExtendAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePreparedStackExtendAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackExtendAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: SyncListResponsePreparedStackExtendAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: SyncListResponsePreparedStackExtendAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackExtendAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type SyncListResponsePreparedStackExtendAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePreparedStackExtendAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePreparedStackExtendAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePreparedStackExtendConditionResource = {
    expression: string;
    title: string;
};
export type SyncListResponsePreparedStackExtendResourceConditionUnion = SyncListResponsePreparedStackExtendConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePreparedStackExtendGcpResource = {
    condition?: SyncListResponsePreparedStackExtendConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePreparedStackExtendConditionStack = {
    expression: string;
    title: string;
};
export type SyncListResponsePreparedStackExtendStackConditionUnion = SyncListResponsePreparedStackExtendConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePreparedStackExtendGcpStack = {
    condition?: SyncListResponsePreparedStackExtendConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackExtendGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: SyncListResponsePreparedStackExtendGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: SyncListResponsePreparedStackExtendGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackExtendGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type SyncListResponsePreparedStackExtendGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePreparedStackExtendGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePreparedStackExtendGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePreparedStackExtendPlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<SyncListResponsePreparedStackExtendAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<SyncListResponsePreparedStackExtendAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<SyncListResponsePreparedStackExtendGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePreparedStackExtend = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: SyncListResponsePreparedStackExtendPlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type SyncListResponsePreparedStackExtendUnion = SyncListResponsePreparedStackExtend | string;
export type SyncListResponsePreparedStackManagement1 = {
    /**
     * Permission profile that maps resources to permission sets
     *
     * @remarks
     * Key can be "*" for all resources or resource name for specific resource
     */
    extend: {
        [k: string]: Array<SyncListResponsePreparedStackExtend | string>;
    };
};
/**
 * Management permissions configuration for stack management access
 */
export type SyncListResponsePreparedStackManagementUnion = SyncListResponsePreparedStackManagement1 | SyncListResponsePreparedStackManagement2 | SyncListResponsePreparedStackManagementEnum;
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePreparedStackProfileAwResource = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * AWS-specific binding specification
 */
export type SyncListResponsePreparedStackProfileAwStack = {
    /**
     * Optional condition for additional filtering (rare)
     */
    condition?: {
        [k: string]: {
            [k: string]: string;
        };
    } | null | undefined;
    /**
     * Resource ARNs to bind to
     */
    resources: Array<string>;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackProfileAwBinding = {
    /**
     * AWS-specific binding specification
     */
    resource?: SyncListResponsePreparedStackProfileAwResource | undefined;
    /**
     * AWS-specific binding specification
     */
    stack?: SyncListResponsePreparedStackProfileAwStack | undefined;
};
/**
 * IAM effect. Defaults to Allow.
 */
export declare const SyncListResponsePreparedStackProfileEffect: {
    readonly Allow: "Allow";
    readonly Deny: "Deny";
};
/**
 * IAM effect. Defaults to Allow.
 */
export type SyncListResponsePreparedStackProfileEffect = ClosedEnum<typeof SyncListResponsePreparedStackProfileEffect>;
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackProfileAwGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * AWS-specific platform permission configuration
 */
export type SyncListResponsePreparedStackProfileAw = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePreparedStackProfileAwBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * IAM effect. Defaults to Allow.
     */
    effect?: SyncListResponsePreparedStackProfileEffect | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePreparedStackProfileAwGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePreparedStackProfileAzureResource = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Azure-specific binding specification
 */
export type SyncListResponsePreparedStackProfileAzureStack = {
    /**
     * Scope (subscription/resource group/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackProfileAzureBinding = {
    /**
     * Azure-specific binding specification
     */
    resource?: SyncListResponsePreparedStackProfileAzureResource | undefined;
    /**
     * Azure-specific binding specification
     */
    stack?: SyncListResponsePreparedStackProfileAzureStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackProfileAzureGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * Azure-specific platform permission configuration
 */
export type SyncListResponsePreparedStackProfileAzure = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePreparedStackProfileAzureBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePreparedStackProfileAzureGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePreparedStackProfileConditionResource = {
    expression: string;
    title: string;
};
export type SyncListResponsePreparedStackProfileResourceConditionUnion = SyncListResponsePreparedStackProfileConditionResource | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePreparedStackProfileGcpResource = {
    condition?: SyncListResponsePreparedStackProfileConditionResource | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * GCP IAM condition
 */
export type SyncListResponsePreparedStackProfileConditionStack = {
    expression: string;
    title: string;
};
export type SyncListResponsePreparedStackProfileStackConditionUnion = SyncListResponsePreparedStackProfileConditionStack | any;
/**
 * GCP-specific binding specification
 */
export type SyncListResponsePreparedStackProfileGcpStack = {
    condition?: SyncListResponsePreparedStackProfileConditionStack | any | null | undefined;
    /**
     * Scope (project/resource level)
     */
    scope: string;
};
/**
 * Generic binding configuration for permissions
 */
export type SyncListResponsePreparedStackProfileGcpBinding = {
    /**
     * GCP-specific binding specification
     */
    resource?: SyncListResponsePreparedStackProfileGcpResource | undefined;
    /**
     * GCP-specific binding specification
     */
    stack?: SyncListResponsePreparedStackProfileGcpStack | undefined;
};
/**
 * Grant permissions for a specific cloud platform
 */
export type SyncListResponsePreparedStackProfileGcpGrant = {
    /**
     * AWS IAM actions (only for AWS)
     */
    actions?: Array<string> | null | undefined;
    /**
     * Azure actions (only for Azure)
     */
    dataActions?: Array<string> | null | undefined;
    /**
     * GCP permissions that require an exact residual custom role.
     */
    permissions?: Array<string> | null | undefined;
    /**
     * Provider predefined roles to bind directly.
     */
    predefinedRoles?: Array<string> | null | undefined;
    /**
     * GCP residual custom permissions to pair with predefined roles.
     */
    residualPermissions?: Array<string> | null | undefined;
};
/**
 * GCP-specific platform permission configuration
 */
export type SyncListResponsePreparedStackProfileGcp = {
    /**
     * Generic binding configuration for permissions
     */
    binding: SyncListResponsePreparedStackProfileGcpBinding;
    /**
     * Short admin-facing description of why this entry exists.
     */
    description?: string | null | undefined;
    /**
     * Grant permissions for a specific cloud platform
     */
    grant: SyncListResponsePreparedStackProfileGcpGrant;
    /**
     * Stable admin-facing label for this permission entry.
     */
    label?: string | null | undefined;
};
/**
 * Platform-specific permission configurations
 */
export type SyncListResponsePreparedStackProfilePlatforms = {
    /**
     * AWS permission configurations
     */
    aws?: Array<SyncListResponsePreparedStackProfileAw> | null | undefined;
    /**
     * Azure permission configurations
     */
    azure?: Array<SyncListResponsePreparedStackProfileAzure> | null | undefined;
    /**
     * GCP permission configurations
     */
    gcp?: Array<SyncListResponsePreparedStackProfileGcp> | null | undefined;
};
/**
 * A permission set that can be applied across different cloud platforms
 */
export type SyncListResponsePreparedStackProfile = {
    /**
     * Human-readable description of what this permission set allows
     */
    description: string;
    /**
     * Unique identifier for the permission set (e.g., "storage/data-read")
     */
    id: string;
    /**
     * Platform-specific permission configurations
     */
    platforms: SyncListResponsePreparedStackProfilePlatforms;
};
/**
 * Reference to a permission set - either by name or inline definition
 */
export type SyncListResponsePreparedStackProfileUnion = SyncListResponsePreparedStackProfile | string;
/**
 * Combined permissions configuration that contains both profiles and management
 */
export type SyncListResponsePreparedStackPermissions = {
    /**
     * Management permissions configuration for stack management access
     */
    management?: SyncListResponsePreparedStackManagement1 | SyncListResponsePreparedStackManagement2 | SyncListResponsePreparedStackManagementEnum | undefined;
    /**
     * Permission profiles that define access control for compute services
     *
     * @remarks
     * Key is the profile name, value is the permission configuration
     */
    profiles: {
        [k: string]: {
            [k: string]: Array<SyncListResponsePreparedStackProfile | string>;
        };
    };
};
/**
 * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
 */
export type SyncListResponsePreparedStackConfig = {
    /**
     * The unique identifier for this specific resource instance. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
     */
    id: string;
    /**
     * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
     */
    type: string;
    additionalProperties?: {
        [k: string]: any | null;
    } | undefined;
};
/**
 * Reference to a resource by its stable id and resource type.
 */
export type SyncListResponsePreparedStackDependency = {
    id: string;
    /**
     * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
     */
    type: string;
};
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export declare const SyncListResponsePreparedStackLifecycle: {
    readonly Frozen: "frozen";
    readonly Live: "live";
};
/**
 * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
 */
export type SyncListResponsePreparedStackLifecycle = ClosedEnum<typeof SyncListResponsePreparedStackLifecycle>;
export type SyncListResponsePreparedStackResources = {
    /**
     * Resource that can hold any resource type in the Alien system. All resources share common 'type' and 'id' fields with additional type-specific properties.
     */
    config: SyncListResponsePreparedStackConfig;
    /**
     * Additional dependencies for this resource beyond those defined in the resource itself.
     *
     * @remarks
     * The total dependencies are: resource.get_dependencies() + this list
     */
    dependencies: Array<SyncListResponsePreparedStackDependency>;
    /**
     * Id of the boolean stack input that decides whether this resource is
     *
     * @remarks
     * created at all. `None` means always create it.
     *
     * Set by `.enabled(input)` in the SDK. Setup emitters render the resource
     * conditionally on the matching template variable, so a deployer who says no
     * never gets the resource, its outputs, or anything derived from it.
     */
    enabledWhen?: string | null | undefined;
    /**
     * Describes the lifecycle of a resource within a stack, determining how it's managed and deployed.
     */
    lifecycle: SyncListResponsePreparedStackLifecycle;
    /**
     * Enable remote bindings for this resource (BYOB use case).
     *
     * @remarks
     * When true, binding params are synced to StackState's `remote_binding_params`.
     * Default: false (prevents sensitive data in synced state).
     */
    remoteAccess?: boolean | undefined;
};
/**
 * Represents the target cloud platform.
 */
export declare const SyncListResponsePreparedStackSupportedPlatform: {
    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 SyncListResponsePreparedStackSupportedPlatform = ClosedEnum<typeof SyncListResponsePreparedStackSupportedPlatform>;
/**
 * A bag of resources, unaware of any cloud.
 */
export type SyncListResponsePreparedStack = {
    /**
     * Unique identifier for the stack
     */
    id: string;
    /**
     * Input definitions required before setup or deployment can proceed.
     */
    inputs?: Array<SyncListResponsePreparedStackInput> | undefined;
    /**
     * Combined permissions configuration that contains both profiles and management
     */
    permissions?: SyncListResponsePreparedStackPermissions | undefined;
    /**
     * Map of resource IDs to their configurations and lifecycle settings
     */
    resources: {
        [k: string]: SyncListResponsePreparedStackResources;
    };
    /**
     * Which platforms this stack supports. When None, all platforms are supported.
     */
    supportedPlatforms?: Array<SyncListResponsePreparedStackSupportedPlatform> | null | undefined;
};
export type SyncListResponsePreparedStackUnion = SyncListResponsePreparedStack | any;
/**
 * One-shot authority for a setup re-import to replace setup-owned resources.
 */
export type SyncListResponseSetupUpdateAuthorization = {
    /**
     * Frozen resource projection from the last successful deployment.
     */
    baselineFrozenDigest: string;
    /**
     * Unique revision used by persistence layers for compare-and-swap updates.
     */
    nonce: string;
    /**
     * Release whose stack was prepared by setup.
     */
    releaseId: string;
    /**
     * Exact setup artifact revision that authored this authority.
     */
    setupFingerprint: string;
    /**
     * Setup fingerprint contract version.
     */
    setupFingerprintVersion: number;
    /**
     * Stable setup target recorded on the imported deployment.
     */
    setupTarget: string;
    /**
     * Frozen resource projection prepared by the setup re-import.
     */
    targetFrozenDigest: string;
};
export type SyncListResponseSetupUpdateAuthorizationUnion = SyncListResponseSetupUpdateAuthorization | any;
/**
 * Runtime metadata for deployment state persistence
 */
export type SyncListResponseRuntimeMetadata = {
    /**
     * Last generated CLI package revision whose direct setup was applied.
     *
     * @remarks
     * This lets a newer generated CLI refresh setup-owned infrastructure once
     * before handing runtime changes back to the hosted manager.
     */
    directSetupRevision?: string | null | undefined;
    /**
     * Actor that owns structural work during the initial setup phase.
     */
    initialSetupAuthority?: SyncListResponseInitialSetupAuthority | undefined;
    /**
     * Hash of the environment variables snapshot that was last synced to the vault
     *
     * @remarks
     * Used to avoid redundant sync operations during incremental deployment
     */
    lastSyncedEnvVarsHash?: string | null | undefined;
    /**
     * Exact vault keys owned by the deployment secret synchronizer. This
     *
     * @remarks
     * inventory lets a later snapshot delete removed keys without listing or
     * touching unrelated values in the same vault.
     */
    lastSyncedSecretNames?: Array<string> | undefined;
    pendingPreparedStack?: SyncListResponsePendingPreparedStack | any | null | undefined;
    /**
     * Canonical resolved answers for inputs that gate Frozen resources,
     *
     * @remarks
     * keyed by input id, recorded when the deployment is created or its
     * setup import registers.
     *
     * A frozen gate's answer is fixed for the deployment's lifetime: the
     * update path refuses input values that conflict with these, and a Live
     * resource sharing such an input resolves the persisted answer forever.
     */
    persistedGateAnswers?: {
        [k: string]: boolean;
    } | undefined;
    preparedStack?: SyncListResponsePreparedStack | any | null | undefined;
    /**
     * Whether cross-account registry access has been successfully granted.
     *
     * @remarks
     * Set to true after the manager successfully sets the ECR/GAR repo policy
     * for this deployment's target account. Prevents redundant API calls on
     * every reconcile tick.
     */
    registryAccessGranted?: boolean | undefined;
    setupUpdateAuthorization?: SyncListResponseSetupUpdateAuthorization | any | null | undefined;
};
/**
 * Setup source that imported this deployment
 */
export declare const SyncListResponseImportSource: {
    readonly Cloudformation: "cloudformation";
    readonly Terraform: "terraform";
    readonly Helm: "helm";
};
/**
 * Setup source that imported this deployment
 */
export type SyncListResponseImportSource = ClosedEnum<typeof SyncListResponseImportSource>;
/**
 * Setup method that created the deployment record and owns setup-time resources.
 */
export declare const SyncListResponseSetupMethod: {
    readonly Cloudformation: "cloudformation";
    readonly GoogleOauth: "google-oauth";
    readonly Terraform: "terraform";
    readonly Helm: "helm";
    readonly Cli: "cli";
    readonly Manual: "manual";
};
/**
 * Setup method that created the deployment record and owns setup-time resources.
 */
export type SyncListResponseSetupMethod = ClosedEnum<typeof SyncListResponseSetupMethod>;
/**
 * Latest error information if the deployment is in a failed state
 */
export type SyncListResponseError = {
    /**
     * A unique identifier for the type of error.
     *
     * @remarks
     *
     * This should be a short, machine-readable string that can be used
     * by clients to programmatically handle different error types.
     * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
     */
    code: string;
    /**
     * Additional diagnostic information about the error context.
     *
     * @remarks
     *
     * This optional field can contain structured data providing more details
     * about the error, such as validation errors, request parameters that
     * caused the issue, or other relevant context information.
     */
    context?: any | null | undefined;
    /**
     * Optional human-facing remediation hint.
     */
    hint?: string | null | undefined;
    /**
     * HTTP status code for this error.
     *
     * @remarks
     *
     * Used when converting the error to an HTTP response. If None, falls back to
     * the error type's default status code or 500.
     */
    httpStatusCode?: number | null | undefined;
    /**
     * Indicates if this is an internal error that should not be exposed to users.
     *
     * @remarks
     *
     * When `true`, this error contains sensitive information or implementation
     * details that should not be shown to end-users. Such errors should be
     * logged for debugging but replaced with generic error messages in responses.
     */
    internal: boolean;
    /**
     * Human-readable error message.
     *
     * @remarks
     *
     * This message should be clear and actionable for developers or end-users,
     * providing context about what went wrong and potentially how to fix it.
     */
    message: string;
    /**
     * Indicates whether the operation that caused the error should be retried.
     *
     * @remarks
     *
     * When `true`, the error is transient and the operation might succeed
     * if attempted again. When `false`, retrying the same operation is
     * unlikely to succeed without changes.
     */
    retryable: boolean;
    /**
     * The underlying error that caused this error, creating an error chain.
     *
     * @remarks
     *
     * This allows for proper error propagation and debugging by maintaining
     * the full context of how an error occurred through multiple layers
     * of an application.
     */
    source?: any | null | undefined;
};
/**
 * Durable progress for deployment updates
 */
export type SyncListResponseUpdateState = {
    active: DeploymentUpdateOperationSummary | null;
    next: DeploymentUpdateOperationSummary | null;
    latest: DeploymentUpdateOperationSummary | null;
};
export declare const SyncListResponsePlatformKubernetes: {
    readonly Kubernetes: "kubernetes";
};
export type SyncListResponsePlatformKubernetes = ClosedEnum<typeof SyncListResponsePlatformKubernetes>;
export type SyncListResponseManagementConfigKubernetes = {
    platform: SyncListResponsePlatformKubernetes;
};
export declare const SyncListResponseManagementConfigPlatformAzure: {
    readonly Azure: "azure";
};
export type SyncListResponseManagementConfigPlatformAzure = ClosedEnum<typeof SyncListResponseManagementConfigPlatformAzure>;
/**
 * Azure management configuration extracted from stack settings
 */
export type SyncListResponseManagementConfigAzure = {
    /**
     * The managing Azure Tenant ID for cross-tenant access
     */
    managingTenantId: string;
    /**
     * OIDC issuer URL trusted by the target-side managed identity.
     */
    oidcIssuer: string;
    /**
     * OIDC subject claim trusted by the target-side managed identity.
     */
    oidcSubject: string;
    platform: SyncListResponseManagementConfigPlatformAzure;
};
export declare const SyncListResponseManagementConfigPlatformGcp: {
    readonly Gcp: "gcp";
};
export type SyncListResponseManagementConfigPlatformGcp = ClosedEnum<typeof SyncListResponseManagementConfigPlatformGcp>;
/**
 * GCP management configuration extracted from stack settings
 */
export type SyncListResponseManagementConfigGcp = {
    /**
     * Service account email for management roles
     */
    serviceAccountEmail: string;
    platform: SyncListResponseManagementConfigPlatformGcp;
};
export declare const SyncListResponseManagementConfigPlatformAws: {
    readonly Aws: "aws";
};
export type SyncListResponseManagementConfigPlatformAws = ClosedEnum<typeof SyncListResponseManagementConfigPlatformAws>;
/**
 * AWS management configuration extracted from stack settings
 */
export type SyncListResponseManagementConfigAws = {
    /**
     * The managing AWS IAM role ARN that can assume cross-account roles
     */
    managingRoleArn: string;
    platform: SyncListResponseManagementConfigPlatformAws;
};
/**
 * Management configuration for different cloud platforms.
 *
 * @remarks
 *
 * Platform-derived configuration for cross-account/cross-tenant access.
 * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
 */
export type SyncListResponseManagementConfigUnion = SyncListResponseManagementConfigAzure | SyncListResponseManagementConfigAws | SyncListResponseManagementConfigGcp | SyncListResponseManagementConfigKubernetes | any;
export type SyncListResponseDeployment = {
    /**
     * Unique identifier for the deployment.
     */
    id: string;
    /**
     * Deployment name.
     */
    name: string;
    /**
     * Public subdomain for auto-generated domains
     */
    publicSubdomain?: string | null | undefined;
    /**
     * Deployment status in the deployment lifecycle.
     *
     * @remarks
     *
     * For observe-only deployments with no release or stack state, `Running`
     * means the Operator is attached. Connectivity comes from `lastHeartbeatAt`;
     * resource health comes from inventory and resource heartbeat data.
     */
    status: SyncListResponseStatus;
    /**
     * Unique identifier for the project.
     */
    projectId: string;
    /**
     * Target platform for the deployment
     */
    platform: SyncListResponsePlatform;
    /**
     * Underlying cloud platform for Kubernetes deployments.
     */
    basePlatform?: SyncListResponseBasePlatform | null | undefined;
    /**
     * Cloud region or location for the deployment.
     */
    region?: string | null | undefined;
    /**
     * DeploymentState protocol version owned by the runtime/manager
     */
    deploymentProtocolVersion: number;
    /**
     * ID of deployment group this deployment belongs to
     */
    deploymentGroupId: string;
    /**
     * Operational purpose of this deployment within its customer environment.
     */
    purpose: DeploymentPurpose;
    /**
     * Cloud environment information
     */
    environmentInfo?: SyncListResponseEnvironmentInfoGcp | SyncListResponseEnvironmentInfoAzure | SyncListResponseEnvironmentInfoLocal | SyncListResponseEnvironmentInfoAws | SyncListResponseEnvironmentInfoTest | any | null | undefined;
    /**
     * User-provided configuration (network, deployment model, approvals)
     */
    stackSettings: SyncListResponseStackSettings;
    /**
     * State of infrastructure components managed by this deployment
     */
    stackState?: SyncListResponseStackState | null | undefined;
    /**
     * Runtime metadata for deployment state persistence
     */
    runtimeMetadata?: SyncListResponseRuntimeMetadata | null | undefined;
    /**
     * ID of the currently deployed release (actual state)
     */
    currentReleaseId?: string | null | undefined;
    /**
     * ID of the desired release for deployment/update (desired state)
     */
    desiredReleaseId?: string | null | undefined;
    /**
     * ID of the pinned release
     */
    pinnedReleaseId?: string | null | undefined;
    releaseChannel: string;
    /**
     * Setup source that imported this deployment
     */
    importSource?: SyncListResponseImportSource | null | undefined;
    /**
     * Setup method that created the deployment record and owns setup-time resources.
     */
    setupMethod?: SyncListResponseSetupMethod | null | undefined;
    /**
     * Setup method metadata needed to guide privileged teardown.
     */
    setupMetadata?: {
        [k: string]: any | null;
    } | null | undefined;
    /**
     * Imported setup target for compatibility checks
     */
    setupTarget?: string | null | undefined;
    /**
     * Imported setup compatibility fingerprint
     */
    setupFingerprint?: string | null | undefined;
    /**
     * Imported setup fingerprint algorithm version
     */
    setupFingerprintVersion?: number | null | undefined;
    /**
     * Display-only scope reported by the Operator manifest
     */
    operatorScope?: string | null | undefined;
    /**
     * Display-only permission tier reported by the Operator manifest
     */
    operatorPermission?: string | null | undefined;
    /**
     * Version reported by the Operator
     */
    operatorVersion?: string | null | undefined;
    /**
     * Capability state reported by the Operator
     */
    capabilities?: Array<OperatorCapabilityReport> | null | undefined;
    /**
     * Enabled-plugin-bundle-set hash the Operator reports having loaded
     */
    observedOperationsBundleHash?: string | null | undefined;
    /**
     * Operations the Operator reports as currently loaded
     */
    observedOperations?: Array<ReportedOperation> | null | undefined;
    /**
     * Whether a retry has been requested for a failed deployment
     */
    retryRequested: boolean;
    /**
     * Timestamp of the last received heartbeat from the deployment
     */
    lastHeartbeatAt?: Date | null | undefined;
    /**
     * Latest error information if the deployment is in a failed state
     */
    error?: SyncListResponseError | null | undefined;
    /**
     * Durable progress for deployment updates
     */
    updateState?: SyncListResponseUpdateState | undefined;
    createdAt: Date;
    updatedAt: Date;
    managerId: string;
    /**
     * Unique identifier for the workspace.
     */
    workspaceId: string;
    userEnvironmentVariables: Array<EnvironmentVariableConfig> | null;
    /**
     * Management configuration for different cloud platforms.
     *
     * @remarks
     *
     * Platform-derived configuration for cross-account/cross-tenant access.
     * This is NOT user-specified - it's derived from the Manager's ServiceAccount.
     */
    managementConfig?: SyncListResponseManagementConfigAzure | SyncListResponseManagementConfigAws | SyncListResponseManagementConfigGcp | SyncListResponseManagementConfigKubernetes | any | null | undefined;
    deploymentToken?: string | null | undefined;
    lockedBy?: string | null | undefined;
    lockedAt?: Date | null | undefined;
};
/**
 * Full deployment records for manager operation
 */
export type SyncListResponse = {
    deployments: Array<SyncListResponseDeployment>;
};
/** @internal */
export 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 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 SyncListResponseExternalBindings$inboundSchema: z.ZodType<SyncListResponseExternalBindings, unknown>;
export declare function syncListResponseExternalBindingsFromJSON(jsonString: string): SafeParseResult<SyncListResponseExternalBindings, SDKValidationError>;
/** @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 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 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>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackTypeBoolean$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackTypeBoolean>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackDefaultBoolean$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackDefaultBoolean, unknown>;
export declare function syncListResponsePendingPreparedStackDefaultBooleanFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackDefaultBoolean, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackTypeNumber$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackTypeNumber>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackDefaultNumber$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackDefaultNumber, unknown>;
export declare function syncListResponsePendingPreparedStackDefaultNumberFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackDefaultNumber, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackTypeString$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackTypeString>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackDefaultString$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackDefaultString, unknown>;
export declare function syncListResponsePendingPreparedStackDefaultStringFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackDefaultString, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackDefaultUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackDefaultUnion, unknown>;
export declare function syncListResponsePendingPreparedStackDefaultUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackDefaultUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackTypeEnvEnum$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackTypeEnvEnum>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackTypeUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackTypeUnion, unknown>;
export declare function syncListResponsePendingPreparedStackTypeUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackTypeUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackEnv$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackEnv, unknown>;
export declare function syncListResponsePendingPreparedStackEnvFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackEnv, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackKind$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackKind>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackPlatform$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackPlatform>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProvidedBy$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackProvidedBy>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackValidation$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackValidation, unknown>;
export declare function syncListResponsePendingPreparedStackValidationFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackValidation, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackValidationUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackValidationUnion, unknown>;
export declare function syncListResponsePendingPreparedStackValidationUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackValidationUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackInput$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackInput, unknown>;
export declare function syncListResponsePendingPreparedStackInputFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackInput, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackManagementEnum$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackManagementEnum>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideAwResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideAwResource, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideAwResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideAwResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideAwStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideAwStack, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideAwStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideAwStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideAwBinding$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideAwBinding, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideAwBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideAwBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideEffect$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackOverrideEffect>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideAwGrant$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideAwGrant, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideAwGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideAwGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideAw$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideAw, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideAwFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideAw, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideAzureResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideAzureResource, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideAzureResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideAzureResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideAzureStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideAzureStack, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideAzureStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideAzureStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideAzureBinding$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideAzureBinding, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideAzureBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideAzureBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideAzureGrant$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideAzureGrant, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideAzureGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideAzureGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideAzure$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideAzure, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideAzure, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideConditionResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideConditionResource, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideConditionResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideConditionResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideResourceConditionUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideResourceConditionUnion, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideGcpResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideGcpResource, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideGcpResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideGcpResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideConditionStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideConditionStack, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideConditionStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideConditionStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideStackConditionUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideStackConditionUnion, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideStackConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideGcpStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideGcpStack, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideGcpStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideGcpStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideGcpBinding$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideGcpBinding, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideGcpBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideGcpBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideGcpGrant$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideGcpGrant, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideGcpGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideGcpGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideGcp$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideGcp, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideGcp, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverridePlatforms$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverridePlatforms, unknown>;
export declare function syncListResponsePendingPreparedStackOverridePlatformsFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverridePlatforms, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverride$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverride, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverride, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackOverrideUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackOverrideUnion, unknown>;
export declare function syncListResponsePendingPreparedStackOverrideUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackOverrideUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackManagement2$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackManagement2, unknown>;
export declare function syncListResponsePendingPreparedStackManagement2FromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackManagement2, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendAwResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendAwResource, unknown>;
export declare function syncListResponsePendingPreparedStackExtendAwResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendAwResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendAwStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendAwStack, unknown>;
export declare function syncListResponsePendingPreparedStackExtendAwStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendAwStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendAwBinding$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendAwBinding, unknown>;
export declare function syncListResponsePendingPreparedStackExtendAwBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendAwBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendEffect$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackExtendEffect>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendAwGrant$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendAwGrant, unknown>;
export declare function syncListResponsePendingPreparedStackExtendAwGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendAwGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendAw$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendAw, unknown>;
export declare function syncListResponsePendingPreparedStackExtendAwFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendAw, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendAzureResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendAzureResource, unknown>;
export declare function syncListResponsePendingPreparedStackExtendAzureResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendAzureResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendAzureStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendAzureStack, unknown>;
export declare function syncListResponsePendingPreparedStackExtendAzureStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendAzureStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendAzureBinding$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendAzureBinding, unknown>;
export declare function syncListResponsePendingPreparedStackExtendAzureBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendAzureBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendAzureGrant$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendAzureGrant, unknown>;
export declare function syncListResponsePendingPreparedStackExtendAzureGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendAzureGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendAzure$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendAzure, unknown>;
export declare function syncListResponsePendingPreparedStackExtendAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendAzure, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendConditionResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendConditionResource, unknown>;
export declare function syncListResponsePendingPreparedStackExtendConditionResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendConditionResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendResourceConditionUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendResourceConditionUnion, unknown>;
export declare function syncListResponsePendingPreparedStackExtendResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendGcpResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendGcpResource, unknown>;
export declare function syncListResponsePendingPreparedStackExtendGcpResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendGcpResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendConditionStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendConditionStack, unknown>;
export declare function syncListResponsePendingPreparedStackExtendConditionStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendConditionStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendStackConditionUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendStackConditionUnion, unknown>;
export declare function syncListResponsePendingPreparedStackExtendStackConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendGcpStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendGcpStack, unknown>;
export declare function syncListResponsePendingPreparedStackExtendGcpStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendGcpStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendGcpBinding$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendGcpBinding, unknown>;
export declare function syncListResponsePendingPreparedStackExtendGcpBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendGcpBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendGcpGrant$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendGcpGrant, unknown>;
export declare function syncListResponsePendingPreparedStackExtendGcpGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendGcpGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendGcp$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendGcp, unknown>;
export declare function syncListResponsePendingPreparedStackExtendGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendGcp, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendPlatforms$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendPlatforms, unknown>;
export declare function syncListResponsePendingPreparedStackExtendPlatformsFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendPlatforms, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtend$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtend, unknown>;
export declare function syncListResponsePendingPreparedStackExtendFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtend, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackExtendUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackExtendUnion, unknown>;
export declare function syncListResponsePendingPreparedStackExtendUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackExtendUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackManagement1$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackManagement1, unknown>;
export declare function syncListResponsePendingPreparedStackManagement1FromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackManagement1, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackManagementUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackManagementUnion, unknown>;
export declare function syncListResponsePendingPreparedStackManagementUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackManagementUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileAwResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileAwResource, unknown>;
export declare function syncListResponsePendingPreparedStackProfileAwResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileAwResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileAwStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileAwStack, unknown>;
export declare function syncListResponsePendingPreparedStackProfileAwStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileAwStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileAwBinding$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileAwBinding, unknown>;
export declare function syncListResponsePendingPreparedStackProfileAwBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileAwBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileEffect$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackProfileEffect>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileAwGrant$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileAwGrant, unknown>;
export declare function syncListResponsePendingPreparedStackProfileAwGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileAwGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileAw$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileAw, unknown>;
export declare function syncListResponsePendingPreparedStackProfileAwFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileAw, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileAzureResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileAzureResource, unknown>;
export declare function syncListResponsePendingPreparedStackProfileAzureResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileAzureResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileAzureStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileAzureStack, unknown>;
export declare function syncListResponsePendingPreparedStackProfileAzureStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileAzureStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileAzureBinding$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileAzureBinding, unknown>;
export declare function syncListResponsePendingPreparedStackProfileAzureBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileAzureBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileAzureGrant$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileAzureGrant, unknown>;
export declare function syncListResponsePendingPreparedStackProfileAzureGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileAzureGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileAzure$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileAzure, unknown>;
export declare function syncListResponsePendingPreparedStackProfileAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileAzure, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileConditionResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileConditionResource, unknown>;
export declare function syncListResponsePendingPreparedStackProfileConditionResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileConditionResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileResourceConditionUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileResourceConditionUnion, unknown>;
export declare function syncListResponsePendingPreparedStackProfileResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileGcpResource$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileGcpResource, unknown>;
export declare function syncListResponsePendingPreparedStackProfileGcpResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileGcpResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileConditionStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileConditionStack, unknown>;
export declare function syncListResponsePendingPreparedStackProfileConditionStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileConditionStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileStackConditionUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileStackConditionUnion, unknown>;
export declare function syncListResponsePendingPreparedStackProfileStackConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileGcpStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileGcpStack, unknown>;
export declare function syncListResponsePendingPreparedStackProfileGcpStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileGcpStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileGcpBinding$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileGcpBinding, unknown>;
export declare function syncListResponsePendingPreparedStackProfileGcpBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileGcpBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileGcpGrant$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileGcpGrant, unknown>;
export declare function syncListResponsePendingPreparedStackProfileGcpGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileGcpGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileGcp$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileGcp, unknown>;
export declare function syncListResponsePendingPreparedStackProfileGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileGcp, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfilePlatforms$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfilePlatforms, unknown>;
export declare function syncListResponsePendingPreparedStackProfilePlatformsFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfilePlatforms, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfile$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfile, unknown>;
export declare function syncListResponsePendingPreparedStackProfileFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfile, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackProfileUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackProfileUnion, unknown>;
export declare function syncListResponsePendingPreparedStackProfileUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackProfileUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackPermissions$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackPermissions, unknown>;
export declare function syncListResponsePendingPreparedStackPermissionsFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackPermissions, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackConfig$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackConfig, unknown>;
export declare function syncListResponsePendingPreparedStackConfigFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackConfig, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackDependency$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackDependency, unknown>;
export declare function syncListResponsePendingPreparedStackDependencyFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackDependency, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackLifecycle$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackLifecycle>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackResources$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackResources, unknown>;
export declare function syncListResponsePendingPreparedStackResourcesFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackResources, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackSupportedPlatform$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingPreparedStackSupportedPlatform>;
/** @internal */
export declare const SyncListResponsePendingPreparedStack$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStack, unknown>;
export declare function syncListResponsePendingPreparedStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePendingPreparedStackUnion$inboundSchema: z.ZodType<SyncListResponsePendingPreparedStackUnion, unknown>;
export declare function syncListResponsePendingPreparedStackUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingPreparedStackUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackTypeStringList$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackTypeStringList>;
/** @internal */
export declare const SyncListResponsePreparedStackDefaultStringList$inboundSchema: z.ZodType<SyncListResponsePreparedStackDefaultStringList, unknown>;
export declare function syncListResponsePreparedStackDefaultStringListFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackDefaultStringList, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackTypeBoolean$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackTypeBoolean>;
/** @internal */
export declare const SyncListResponsePreparedStackDefaultBoolean$inboundSchema: z.ZodType<SyncListResponsePreparedStackDefaultBoolean, unknown>;
export declare function syncListResponsePreparedStackDefaultBooleanFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackDefaultBoolean, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackTypeNumber$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackTypeNumber>;
/** @internal */
export declare const SyncListResponsePreparedStackDefaultNumber$inboundSchema: z.ZodType<SyncListResponsePreparedStackDefaultNumber, unknown>;
export declare function syncListResponsePreparedStackDefaultNumberFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackDefaultNumber, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackTypeString$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackTypeString>;
/** @internal */
export declare const SyncListResponsePreparedStackDefaultString$inboundSchema: z.ZodType<SyncListResponsePreparedStackDefaultString, unknown>;
export declare function syncListResponsePreparedStackDefaultStringFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackDefaultString, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackDefaultUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackDefaultUnion, unknown>;
export declare function syncListResponsePreparedStackDefaultUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackDefaultUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackTypeEnvEnum$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackTypeEnvEnum>;
/** @internal */
export declare const SyncListResponsePreparedStackTypeUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackTypeUnion, unknown>;
export declare function syncListResponsePreparedStackTypeUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackTypeUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackEnv$inboundSchema: z.ZodType<SyncListResponsePreparedStackEnv, unknown>;
export declare function syncListResponsePreparedStackEnvFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackEnv, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackKind$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackKind>;
/** @internal */
export declare const SyncListResponsePreparedStackPlatform$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackPlatform>;
/** @internal */
export declare const SyncListResponsePreparedStackProvidedBy$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackProvidedBy>;
/** @internal */
export declare const SyncListResponsePreparedStackValidation$inboundSchema: z.ZodType<SyncListResponsePreparedStackValidation, unknown>;
export declare function syncListResponsePreparedStackValidationFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackValidation, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackValidationUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackValidationUnion, unknown>;
export declare function syncListResponsePreparedStackValidationUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackValidationUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackInput$inboundSchema: z.ZodType<SyncListResponsePreparedStackInput, unknown>;
export declare function syncListResponsePreparedStackInputFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackInput, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackManagementEnum$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackManagementEnum>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideAwResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideAwResource, unknown>;
export declare function syncListResponsePreparedStackOverrideAwResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideAwResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideAwStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideAwStack, unknown>;
export declare function syncListResponsePreparedStackOverrideAwStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideAwStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideAwBinding$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideAwBinding, unknown>;
export declare function syncListResponsePreparedStackOverrideAwBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideAwBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideEffect$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackOverrideEffect>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideAwGrant$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideAwGrant, unknown>;
export declare function syncListResponsePreparedStackOverrideAwGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideAwGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideAw$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideAw, unknown>;
export declare function syncListResponsePreparedStackOverrideAwFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideAw, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideAzureResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideAzureResource, unknown>;
export declare function syncListResponsePreparedStackOverrideAzureResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideAzureResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideAzureStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideAzureStack, unknown>;
export declare function syncListResponsePreparedStackOverrideAzureStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideAzureStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideAzureBinding$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideAzureBinding, unknown>;
export declare function syncListResponsePreparedStackOverrideAzureBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideAzureBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideAzureGrant$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideAzureGrant, unknown>;
export declare function syncListResponsePreparedStackOverrideAzureGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideAzureGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideAzure$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideAzure, unknown>;
export declare function syncListResponsePreparedStackOverrideAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideAzure, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideConditionResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideConditionResource, unknown>;
export declare function syncListResponsePreparedStackOverrideConditionResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideConditionResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideResourceConditionUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideResourceConditionUnion, unknown>;
export declare function syncListResponsePreparedStackOverrideResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideGcpResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideGcpResource, unknown>;
export declare function syncListResponsePreparedStackOverrideGcpResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideGcpResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideConditionStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideConditionStack, unknown>;
export declare function syncListResponsePreparedStackOverrideConditionStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideConditionStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideStackConditionUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideStackConditionUnion, unknown>;
export declare function syncListResponsePreparedStackOverrideStackConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideGcpStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideGcpStack, unknown>;
export declare function syncListResponsePreparedStackOverrideGcpStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideGcpStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideGcpBinding$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideGcpBinding, unknown>;
export declare function syncListResponsePreparedStackOverrideGcpBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideGcpBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideGcpGrant$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideGcpGrant, unknown>;
export declare function syncListResponsePreparedStackOverrideGcpGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideGcpGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideGcp$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideGcp, unknown>;
export declare function syncListResponsePreparedStackOverrideGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideGcp, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverridePlatforms$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverridePlatforms, unknown>;
export declare function syncListResponsePreparedStackOverridePlatformsFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverridePlatforms, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverride$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverride, unknown>;
export declare function syncListResponsePreparedStackOverrideFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverride, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackOverrideUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackOverrideUnion, unknown>;
export declare function syncListResponsePreparedStackOverrideUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackOverrideUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackManagement2$inboundSchema: z.ZodType<SyncListResponsePreparedStackManagement2, unknown>;
export declare function syncListResponsePreparedStackManagement2FromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackManagement2, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendAwResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendAwResource, unknown>;
export declare function syncListResponsePreparedStackExtendAwResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendAwResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendAwStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendAwStack, unknown>;
export declare function syncListResponsePreparedStackExtendAwStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendAwStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendAwBinding$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendAwBinding, unknown>;
export declare function syncListResponsePreparedStackExtendAwBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendAwBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendEffect$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackExtendEffect>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendAwGrant$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendAwGrant, unknown>;
export declare function syncListResponsePreparedStackExtendAwGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendAwGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendAw$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendAw, unknown>;
export declare function syncListResponsePreparedStackExtendAwFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendAw, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendAzureResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendAzureResource, unknown>;
export declare function syncListResponsePreparedStackExtendAzureResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendAzureResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendAzureStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendAzureStack, unknown>;
export declare function syncListResponsePreparedStackExtendAzureStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendAzureStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendAzureBinding$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendAzureBinding, unknown>;
export declare function syncListResponsePreparedStackExtendAzureBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendAzureBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendAzureGrant$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendAzureGrant, unknown>;
export declare function syncListResponsePreparedStackExtendAzureGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendAzureGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendAzure$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendAzure, unknown>;
export declare function syncListResponsePreparedStackExtendAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendAzure, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendConditionResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendConditionResource, unknown>;
export declare function syncListResponsePreparedStackExtendConditionResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendConditionResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendResourceConditionUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendResourceConditionUnion, unknown>;
export declare function syncListResponsePreparedStackExtendResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendGcpResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendGcpResource, unknown>;
export declare function syncListResponsePreparedStackExtendGcpResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendGcpResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendConditionStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendConditionStack, unknown>;
export declare function syncListResponsePreparedStackExtendConditionStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendConditionStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendStackConditionUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendStackConditionUnion, unknown>;
export declare function syncListResponsePreparedStackExtendStackConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendGcpStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendGcpStack, unknown>;
export declare function syncListResponsePreparedStackExtendGcpStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendGcpStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendGcpBinding$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendGcpBinding, unknown>;
export declare function syncListResponsePreparedStackExtendGcpBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendGcpBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendGcpGrant$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendGcpGrant, unknown>;
export declare function syncListResponsePreparedStackExtendGcpGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendGcpGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendGcp$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendGcp, unknown>;
export declare function syncListResponsePreparedStackExtendGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendGcp, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendPlatforms$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendPlatforms, unknown>;
export declare function syncListResponsePreparedStackExtendPlatformsFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendPlatforms, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtend$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtend, unknown>;
export declare function syncListResponsePreparedStackExtendFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtend, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackExtendUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackExtendUnion, unknown>;
export declare function syncListResponsePreparedStackExtendUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackExtendUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackManagement1$inboundSchema: z.ZodType<SyncListResponsePreparedStackManagement1, unknown>;
export declare function syncListResponsePreparedStackManagement1FromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackManagement1, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackManagementUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackManagementUnion, unknown>;
export declare function syncListResponsePreparedStackManagementUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackManagementUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileAwResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileAwResource, unknown>;
export declare function syncListResponsePreparedStackProfileAwResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileAwResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileAwStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileAwStack, unknown>;
export declare function syncListResponsePreparedStackProfileAwStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileAwStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileAwBinding$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileAwBinding, unknown>;
export declare function syncListResponsePreparedStackProfileAwBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileAwBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileEffect$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackProfileEffect>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileAwGrant$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileAwGrant, unknown>;
export declare function syncListResponsePreparedStackProfileAwGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileAwGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileAw$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileAw, unknown>;
export declare function syncListResponsePreparedStackProfileAwFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileAw, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileAzureResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileAzureResource, unknown>;
export declare function syncListResponsePreparedStackProfileAzureResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileAzureResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileAzureStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileAzureStack, unknown>;
export declare function syncListResponsePreparedStackProfileAzureStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileAzureStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileAzureBinding$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileAzureBinding, unknown>;
export declare function syncListResponsePreparedStackProfileAzureBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileAzureBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileAzureGrant$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileAzureGrant, unknown>;
export declare function syncListResponsePreparedStackProfileAzureGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileAzureGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileAzure$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileAzure, unknown>;
export declare function syncListResponsePreparedStackProfileAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileAzure, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileConditionResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileConditionResource, unknown>;
export declare function syncListResponsePreparedStackProfileConditionResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileConditionResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileResourceConditionUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileResourceConditionUnion, unknown>;
export declare function syncListResponsePreparedStackProfileResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileResourceConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileGcpResource$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileGcpResource, unknown>;
export declare function syncListResponsePreparedStackProfileGcpResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileGcpResource, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileConditionStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileConditionStack, unknown>;
export declare function syncListResponsePreparedStackProfileConditionStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileConditionStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileStackConditionUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileStackConditionUnion, unknown>;
export declare function syncListResponsePreparedStackProfileStackConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileStackConditionUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileGcpStack$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileGcpStack, unknown>;
export declare function syncListResponsePreparedStackProfileGcpStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileGcpStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileGcpBinding$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileGcpBinding, unknown>;
export declare function syncListResponsePreparedStackProfileGcpBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileGcpBinding, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileGcpGrant$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileGcpGrant, unknown>;
export declare function syncListResponsePreparedStackProfileGcpGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileGcpGrant, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileGcp$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileGcp, unknown>;
export declare function syncListResponsePreparedStackProfileGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileGcp, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfilePlatforms$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfilePlatforms, unknown>;
export declare function syncListResponsePreparedStackProfilePlatformsFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfilePlatforms, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfile$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfile, unknown>;
export declare function syncListResponsePreparedStackProfileFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfile, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackProfileUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackProfileUnion, unknown>;
export declare function syncListResponsePreparedStackProfileUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackProfileUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackPermissions$inboundSchema: z.ZodType<SyncListResponsePreparedStackPermissions, unknown>;
export declare function syncListResponsePreparedStackPermissionsFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackPermissions, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackConfig$inboundSchema: z.ZodType<SyncListResponsePreparedStackConfig, unknown>;
export declare function syncListResponsePreparedStackConfigFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackConfig, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackDependency$inboundSchema: z.ZodType<SyncListResponsePreparedStackDependency, unknown>;
export declare function syncListResponsePreparedStackDependencyFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackDependency, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackLifecycle$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackLifecycle>;
/** @internal */
export declare const SyncListResponsePreparedStackResources$inboundSchema: z.ZodType<SyncListResponsePreparedStackResources, unknown>;
export declare function syncListResponsePreparedStackResourcesFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackResources, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackSupportedPlatform$inboundSchema: z.ZodEnum<typeof SyncListResponsePreparedStackSupportedPlatform>;
/** @internal */
export declare const SyncListResponsePreparedStack$inboundSchema: z.ZodType<SyncListResponsePreparedStack, unknown>;
export declare function syncListResponsePreparedStackFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStack, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePreparedStackUnion$inboundSchema: z.ZodType<SyncListResponsePreparedStackUnion, unknown>;
export declare function syncListResponsePreparedStackUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePreparedStackUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponseSetupUpdateAuthorization$inboundSchema: z.ZodType<SyncListResponseSetupUpdateAuthorization, unknown>;
export declare function syncListResponseSetupUpdateAuthorizationFromJSON(jsonString: string): SafeParseResult<SyncListResponseSetupUpdateAuthorization, SDKValidationError>;
/** @internal */
export declare const SyncListResponseSetupUpdateAuthorizationUnion$inboundSchema: z.ZodType<SyncListResponseSetupUpdateAuthorizationUnion, unknown>;
export declare function syncListResponseSetupUpdateAuthorizationUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseSetupUpdateAuthorizationUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponseRuntimeMetadata$inboundSchema: z.ZodType<SyncListResponseRuntimeMetadata, unknown>;
export declare function syncListResponseRuntimeMetadataFromJSON(jsonString: string): SafeParseResult<SyncListResponseRuntimeMetadata, SDKValidationError>;
/** @internal */
export declare const SyncListResponseImportSource$inboundSchema: z.ZodEnum<typeof SyncListResponseImportSource>;
/** @internal */
export declare const SyncListResponseSetupMethod$inboundSchema: z.ZodEnum<typeof SyncListResponseSetupMethod>;
/** @internal */
export declare const SyncListResponseError$inboundSchema: z.ZodType<SyncListResponseError, unknown>;
export declare function syncListResponseErrorFromJSON(jsonString: string): SafeParseResult<SyncListResponseError, SDKValidationError>;
/** @internal */
export declare const SyncListResponseUpdateState$inboundSchema: z.ZodType<SyncListResponseUpdateState, unknown>;
export declare function syncListResponseUpdateStateFromJSON(jsonString: string): SafeParseResult<SyncListResponseUpdateState, SDKValidationError>;
/** @internal */
export declare const SyncListResponsePlatformKubernetes$inboundSchema: z.ZodEnum<typeof SyncListResponsePlatformKubernetes>;
/** @internal */
export declare const SyncListResponseManagementConfigKubernetes$inboundSchema: z.ZodType<SyncListResponseManagementConfigKubernetes, unknown>;
export declare function syncListResponseManagementConfigKubernetesFromJSON(jsonString: string): SafeParseResult<SyncListResponseManagementConfigKubernetes, SDKValidationError>;
/** @internal */
export declare const SyncListResponseManagementConfigPlatformAzure$inboundSchema: z.ZodEnum<typeof SyncListResponseManagementConfigPlatformAzure>;
/** @internal */
export declare const SyncListResponseManagementConfigAzure$inboundSchema: z.ZodType<SyncListResponseManagementConfigAzure, unknown>;
export declare function syncListResponseManagementConfigAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponseManagementConfigAzure, SDKValidationError>;
/** @internal */
export declare const SyncListResponseManagementConfigPlatformGcp$inboundSchema: z.ZodEnum<typeof SyncListResponseManagementConfigPlatformGcp>;
/** @internal */
export declare const SyncListResponseManagementConfigGcp$inboundSchema: z.ZodType<SyncListResponseManagementConfigGcp, unknown>;
export declare function syncListResponseManagementConfigGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponseManagementConfigGcp, SDKValidationError>;
/** @internal */
export declare const SyncListResponseManagementConfigPlatformAws$inboundSchema: z.ZodEnum<typeof SyncListResponseManagementConfigPlatformAws>;
/** @internal */
export declare const SyncListResponseManagementConfigAws$inboundSchema: z.ZodType<SyncListResponseManagementConfigAws, unknown>;
export declare function syncListResponseManagementConfigAwsFromJSON(jsonString: string): SafeParseResult<SyncListResponseManagementConfigAws, SDKValidationError>;
/** @internal */
export declare const SyncListResponseManagementConfigUnion$inboundSchema: z.ZodType<SyncListResponseManagementConfigUnion, unknown>;
export declare function syncListResponseManagementConfigUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseManagementConfigUnion, SDKValidationError>;
/** @internal */
export declare const SyncListResponseDeployment$inboundSchema: z.ZodType<SyncListResponseDeployment, unknown>;
export declare function syncListResponseDeploymentFromJSON(jsonString: string): SafeParseResult<SyncListResponseDeployment, SDKValidationError>;
/** @internal */
export declare const SyncListResponse$inboundSchema: z.ZodType<SyncListResponse, unknown>;
export declare function syncListResponseFromJSON(jsonString: string): SafeParseResult<SyncListResponse, SDKValidationError>;
//# sourceMappingURL=synclistresponse.d.ts.map