@alienplatform/platform-api 1.3.4 → 1.4.0

package/esm/models/synclistresponse.d.ts

@@ -0,0 +1,3272 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { EnvironmentVariableConfig } from "./environmentvariableconfig.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Deployment status in the deployment lifecycle
+ */
+export declare const SyncListResponseStatus: {
+    readonly Pending: "pending";
+    readonly InitialSetup: "initial-setup";
+    readonly InitialSetupFailed: "initial-setup-failed";
+    readonly Provisioning: "provisioning";
+    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 Deleted: "deleted";
+    readonly Error: "error";
+};
+/**
+ * Deployment status in the deployment lifecycle
+ */
+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 Local: "local";
+    readonly Test: "test";
+};
+/**
+ * Target platform for the deployment
+ */
+export type SyncListResponsePlatform = ClosedEnum<typeof SyncListResponsePlatform>;
+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;
+/**
+ * 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;
+};
+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;
+};
+/**
+ * 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;
+};
+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 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 = {
+    /**
+     * 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;
+    /**
+     * 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 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 Local: "local";
+    readonly Test: "test";
+};
+/**
+ * Represents the target cloud platform.
+ */
+export type SyncListResponseControllerPlatformEnum = ClosedEnum<typeof SyncListResponseControllerPlatformEnum>;
+export type SyncListResponseControllerPlatformUnion = SyncListResponseControllerPlatformEnum | any;
+/**
+ * New ResourceRef that works with any resource type.
+ *
+ * @remarks
+ * This can eventually replace the enum-based ResourceRef for full extensibility.
+ */
+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 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;
+    };
+};
+/**
+ * Scope for a delete operation.
+ *
+ * @remarks
+ *
+ * Full deletes are setup/admin owned and may remove both Frozen and Live
+ * resources. Live-only deletes are used by setup handoff resources
+ * (Terraform/CloudFormation) so Alien removes only the resources it owns
+ * before setup tears down Frozen resources.
+ */
+export declare const SyncListResponseDeleteScopeEnum: {
+    readonly Full: "full";
+    readonly LiveOnly: "liveOnly";
+};
+/**
+ * Scope for a delete operation.
+ *
+ * @remarks
+ *
+ * Full deletes are setup/admin owned and may remove both Frozen and Live
+ * resources. Live-only deletes are used by setup handoff resources
+ * (Terraform/CloudFormation) so Alien removes only the resources it owns
+ * before setup tears down Frozen resources.
+ */
+export type SyncListResponseDeleteScopeEnum = ClosedEnum<typeof SyncListResponseDeleteScopeEnum>;
+export type SyncListResponseDeleteScopeUnion = SyncListResponseDeleteScopeEnum | any;
+/**
+ * Scope for a delete operation.
+ *
+ * @remarks
+ *
+ * Full deletes are setup/admin owned and may remove both Frozen and Live
+ * resources. Live-only deletes are used by setup handoff resources
+ * (Terraform/CloudFormation) so Alien removes only the resources it owns
+ * before setup tears down Frozen resources.
+ */
+export declare const SyncListResponsePendingDeleteScopeEnum: {
+    readonly Full: "full";
+    readonly LiveOnly: "liveOnly";
+};
+/**
+ * Scope for a delete operation.
+ *
+ * @remarks
+ *
+ * Full deletes are setup/admin owned and may remove both Frozen and Live
+ * resources. Live-only deletes are used by setup handoff resources
+ * (Terraform/CloudFormation) so Alien removes only the resources it owns
+ * before setup tears down Frozen resources.
+ */
+export type SyncListResponsePendingDeleteScopeEnum = ClosedEnum<typeof SyncListResponsePendingDeleteScopeEnum>;
+export type SyncListResponsePendingDeleteScopeUnion = SyncListResponsePendingDeleteScopeEnum | any;
+export declare const SyncListResponseManagementEnum: {
+    readonly Auto: "auto";
+};
+export type SyncListResponseManagementEnum = ClosedEnum<typeof SyncListResponseManagementEnum>;
+/**
+ * AWS-specific binding specification
+ */
+export type SyncListResponseOverrideAwResource = {
+    /**
+     * 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 SyncListResponseOverrideAwStack = {
+    /**
+     * 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 SyncListResponseOverrideAwBinding = {
+    /**
+     * AWS-specific binding specification
+     */
+    resource?: SyncListResponseOverrideAwResource | undefined;
+    /**
+     * AWS-specific binding specification
+     */
+    stack?: SyncListResponseOverrideAwStack | undefined;
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export declare const SyncListResponseOverrideEffect: {
+    readonly Allow: "Allow";
+    readonly Deny: "Deny";
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export type SyncListResponseOverrideEffect = ClosedEnum<typeof SyncListResponseOverrideEffect>;
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type SyncListResponseOverrideAwGrant = {
+    /**
+     * 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 SyncListResponseOverrideAw = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: SyncListResponseOverrideAwBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * IAM effect. Defaults to Allow.
+     */
+    effect?: SyncListResponseOverrideEffect | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: SyncListResponseOverrideAwGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type SyncListResponseOverrideAzureResource = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type SyncListResponseOverrideAzureStack = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type SyncListResponseOverrideAzureBinding = {
+    /**
+     * Azure-specific binding specification
+     */
+    resource?: SyncListResponseOverrideAzureResource | undefined;
+    /**
+     * Azure-specific binding specification
+     */
+    stack?: SyncListResponseOverrideAzureStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type SyncListResponseOverrideAzureGrant = {
+    /**
+     * 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 SyncListResponseOverrideAzure = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: SyncListResponseOverrideAzureBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: SyncListResponseOverrideAzureGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * GCP IAM condition
+ */
+export type SyncListResponseOverrideConditionResource = {
+    expression: string;
+    title: string;
+};
+export type SyncListResponseOverrideResourceConditionUnion = SyncListResponseOverrideConditionResource | any;
+/**
+ * GCP-specific binding specification
+ */
+export type SyncListResponseOverrideGcpResource = {
+    condition?: SyncListResponseOverrideConditionResource | any | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * GCP IAM condition
+ */
+export type SyncListResponseOverrideConditionStack = {
+    expression: string;
+    title: string;
+};
+export type SyncListResponseOverrideStackConditionUnion = SyncListResponseOverrideConditionStack | any;
+/**
+ * GCP-specific binding specification
+ */
+export type SyncListResponseOverrideGcpStack = {
+    condition?: SyncListResponseOverrideConditionStack | any | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type SyncListResponseOverrideGcpBinding = {
+    /**
+     * GCP-specific binding specification
+     */
+    resource?: SyncListResponseOverrideGcpResource | undefined;
+    /**
+     * GCP-specific binding specification
+     */
+    stack?: SyncListResponseOverrideGcpStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type SyncListResponseOverrideGcpGrant = {
+    /**
+     * 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 SyncListResponseOverrideGcp = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: SyncListResponseOverrideGcpBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: SyncListResponseOverrideGcpGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Platform-specific permission configurations
+ */
+export type SyncListResponseOverridePlatforms = {
+    /**
+     * AWS permission configurations
+     */
+    aws?: Array<SyncListResponseOverrideAw> | null | undefined;
+    /**
+     * Azure permission configurations
+     */
+    azure?: Array<SyncListResponseOverrideAzure> | null | undefined;
+    /**
+     * GCP permission configurations
+     */
+    gcp?: Array<SyncListResponseOverrideGcp> | null | undefined;
+};
+/**
+ * A permission set that can be applied across different cloud platforms
+ */
+export type SyncListResponseOverride = {
+    /**
+     * 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: SyncListResponseOverridePlatforms;
+};
+/**
+ * Reference to a permission set - either by name or inline definition
+ */
+export type SyncListResponseOverrideUnion = SyncListResponseOverride | string;
+export type SyncListResponseManagement2 = {
+    /**
+     * 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<SyncListResponseOverride | string>;
+    };
+};
+/**
+ * AWS-specific binding specification
+ */
+export type SyncListResponseExtendAwResource = {
+    /**
+     * 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 SyncListResponseExtendAwStack = {
+    /**
+     * 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 SyncListResponseExtendAwBinding = {
+    /**
+     * AWS-specific binding specification
+     */
+    resource?: SyncListResponseExtendAwResource | undefined;
+    /**
+     * AWS-specific binding specification
+     */
+    stack?: SyncListResponseExtendAwStack | undefined;
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export declare const SyncListResponseExtendEffect: {
+    readonly Allow: "Allow";
+    readonly Deny: "Deny";
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export type SyncListResponseExtendEffect = ClosedEnum<typeof SyncListResponseExtendEffect>;
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type SyncListResponseExtendAwGrant = {
+    /**
+     * 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 SyncListResponseExtendAw = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: SyncListResponseExtendAwBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * IAM effect. Defaults to Allow.
+     */
+    effect?: SyncListResponseExtendEffect | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: SyncListResponseExtendAwGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type SyncListResponseExtendAzureResource = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type SyncListResponseExtendAzureStack = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type SyncListResponseExtendAzureBinding = {
+    /**
+     * Azure-specific binding specification
+     */
+    resource?: SyncListResponseExtendAzureResource | undefined;
+    /**
+     * Azure-specific binding specification
+     */
+    stack?: SyncListResponseExtendAzureStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type SyncListResponseExtendAzureGrant = {
+    /**
+     * 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 SyncListResponseExtendAzure = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: SyncListResponseExtendAzureBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: SyncListResponseExtendAzureGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * GCP IAM condition
+ */
+export type SyncListResponseExtendConditionResource = {
+    expression: string;
+    title: string;
+};
+export type SyncListResponseExtendResourceConditionUnion = SyncListResponseExtendConditionResource | any;
+/**
+ * GCP-specific binding specification
+ */
+export type SyncListResponseExtendGcpResource = {
+    condition?: SyncListResponseExtendConditionResource | any | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * GCP IAM condition
+ */
+export type SyncListResponseExtendConditionStack = {
+    expression: string;
+    title: string;
+};
+export type SyncListResponseExtendStackConditionUnion = SyncListResponseExtendConditionStack | any;
+/**
+ * GCP-specific binding specification
+ */
+export type SyncListResponseExtendGcpStack = {
+    condition?: SyncListResponseExtendConditionStack | any | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type SyncListResponseExtendGcpBinding = {
+    /**
+     * GCP-specific binding specification
+     */
+    resource?: SyncListResponseExtendGcpResource | undefined;
+    /**
+     * GCP-specific binding specification
+     */
+    stack?: SyncListResponseExtendGcpStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type SyncListResponseExtendGcpGrant = {
+    /**
+     * 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 SyncListResponseExtendGcp = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: SyncListResponseExtendGcpBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: SyncListResponseExtendGcpGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Platform-specific permission configurations
+ */
+export type SyncListResponseExtendPlatforms = {
+    /**
+     * AWS permission configurations
+     */
+    aws?: Array<SyncListResponseExtendAw> | null | undefined;
+    /**
+     * Azure permission configurations
+     */
+    azure?: Array<SyncListResponseExtendAzure> | null | undefined;
+    /**
+     * GCP permission configurations
+     */
+    gcp?: Array<SyncListResponseExtendGcp> | null | undefined;
+};
+/**
+ * A permission set that can be applied across different cloud platforms
+ */
+export type SyncListResponseExtend = {
+    /**
+     * 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: SyncListResponseExtendPlatforms;
+};
+/**
+ * Reference to a permission set - either by name or inline definition
+ */
+export type SyncListResponseExtendUnion = SyncListResponseExtend | string;
+export type SyncListResponseManagement1 = {
+    /**
+     * 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<SyncListResponseExtend | string>;
+    };
+};
+/**
+ * Management permissions configuration for stack management access
+ */
+export type SyncListResponseManagementUnion = SyncListResponseManagement1 | SyncListResponseManagement2 | SyncListResponseManagementEnum;
+/**
+ * AWS-specific binding specification
+ */
+export type SyncListResponseProfileAwResource = {
+    /**
+     * 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 SyncListResponseProfileAwStack = {
+    /**
+     * 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 SyncListResponseProfileAwBinding = {
+    /**
+     * AWS-specific binding specification
+     */
+    resource?: SyncListResponseProfileAwResource | undefined;
+    /**
+     * AWS-specific binding specification
+     */
+    stack?: SyncListResponseProfileAwStack | undefined;
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export declare const SyncListResponseProfileEffect: {
+    readonly Allow: "Allow";
+    readonly Deny: "Deny";
+};
+/**
+ * IAM effect. Defaults to Allow.
+ */
+export type SyncListResponseProfileEffect = ClosedEnum<typeof SyncListResponseProfileEffect>;
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type SyncListResponseProfileAwGrant = {
+    /**
+     * 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 SyncListResponseProfileAw = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: SyncListResponseProfileAwBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * IAM effect. Defaults to Allow.
+     */
+    effect?: SyncListResponseProfileEffect | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: SyncListResponseProfileAwGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type SyncListResponseProfileAzureResource = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Azure-specific binding specification
+ */
+export type SyncListResponseProfileAzureStack = {
+    /**
+     * Scope (subscription/resource group/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type SyncListResponseProfileAzureBinding = {
+    /**
+     * Azure-specific binding specification
+     */
+    resource?: SyncListResponseProfileAzureResource | undefined;
+    /**
+     * Azure-specific binding specification
+     */
+    stack?: SyncListResponseProfileAzureStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type SyncListResponseProfileAzureGrant = {
+    /**
+     * 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 SyncListResponseProfileAzure = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: SyncListResponseProfileAzureBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: SyncListResponseProfileAzureGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * GCP IAM condition
+ */
+export type SyncListResponseProfileConditionResource = {
+    expression: string;
+    title: string;
+};
+export type SyncListResponseProfileResourceConditionUnion = SyncListResponseProfileConditionResource | any;
+/**
+ * GCP-specific binding specification
+ */
+export type SyncListResponseProfileGcpResource = {
+    condition?: SyncListResponseProfileConditionResource | any | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * GCP IAM condition
+ */
+export type SyncListResponseProfileConditionStack = {
+    expression: string;
+    title: string;
+};
+export type SyncListResponseProfileStackConditionUnion = SyncListResponseProfileConditionStack | any;
+/**
+ * GCP-specific binding specification
+ */
+export type SyncListResponseProfileGcpStack = {
+    condition?: SyncListResponseProfileConditionStack | any | null | undefined;
+    /**
+     * Scope (project/resource level)
+     */
+    scope: string;
+};
+/**
+ * Generic binding configuration for permissions
+ */
+export type SyncListResponseProfileGcpBinding = {
+    /**
+     * GCP-specific binding specification
+     */
+    resource?: SyncListResponseProfileGcpResource | undefined;
+    /**
+     * GCP-specific binding specification
+     */
+    stack?: SyncListResponseProfileGcpStack | undefined;
+};
+/**
+ * Grant permissions for a specific cloud platform
+ */
+export type SyncListResponseProfileGcpGrant = {
+    /**
+     * 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 SyncListResponseProfileGcp = {
+    /**
+     * Generic binding configuration for permissions
+     */
+    binding: SyncListResponseProfileGcpBinding;
+    /**
+     * Short admin-facing description of why this entry exists.
+     */
+    description?: string | null | undefined;
+    /**
+     * Grant permissions for a specific cloud platform
+     */
+    grant: SyncListResponseProfileGcpGrant;
+    /**
+     * Stable admin-facing label for this permission entry.
+     */
+    label?: string | null | undefined;
+};
+/**
+ * Platform-specific permission configurations
+ */
+export type SyncListResponseProfilePlatforms = {
+    /**
+     * AWS permission configurations
+     */
+    aws?: Array<SyncListResponseProfileAw> | null | undefined;
+    /**
+     * Azure permission configurations
+     */
+    azure?: Array<SyncListResponseProfileAzure> | null | undefined;
+    /**
+     * GCP permission configurations
+     */
+    gcp?: Array<SyncListResponseProfileGcp> | null | undefined;
+};
+/**
+ * A permission set that can be applied across different cloud platforms
+ */
+export type SyncListResponseProfile = {
+    /**
+     * 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: SyncListResponseProfilePlatforms;
+};
+/**
+ * Reference to a permission set - either by name or inline definition
+ */
+export type SyncListResponseProfileUnion = SyncListResponseProfile | string;
+/**
+ * Combined permissions configuration that contains both profiles and management
+ */
+export type SyncListResponsePermissions = {
+    /**
+     * Management permissions configuration for stack management access
+     */
+    management?: SyncListResponseManagement1 | SyncListResponseManagement2 | SyncListResponseManagementEnum | 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<SyncListResponseProfile | 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;
+};
+/**
+ * New ResourceRef that works with any resource type.
+ *
+ * @remarks
+ * This can eventually replace the enum-based ResourceRef for full extensibility.
+ */
+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>;
+    /**
+     * 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 SyncListResponseSupportedPlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+    readonly Kubernetes: "kubernetes";
+    readonly Local: "local";
+    readonly Test: "test";
+};
+/**
+ * Represents the target cloud platform.
+ */
+export type SyncListResponseSupportedPlatform = ClosedEnum<typeof SyncListResponseSupportedPlatform>;
+/**
+ * A bag of resources, unaware of any cloud.
+ */
+export type SyncListResponsePreparedStack = {
+    /**
+     * Unique identifier for the stack
+     */
+    id: string;
+    /**
+     * Combined permissions configuration that contains both profiles and management
+     */
+    permissions?: SyncListResponsePermissions | 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<SyncListResponseSupportedPlatform> | null | undefined;
+};
+export type SyncListResponsePreparedStackUnion = SyncListResponsePreparedStack | any;
+/**
+ * Runtime metadata for deployment state persistence
+ */
+export type SyncListResponseRuntimeMetadata = {
+    deleteScope?: SyncListResponseDeleteScopeEnum | any | null | 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;
+    pendingDeleteScope?: SyncListResponsePendingDeleteScopeEnum | any | null | 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;
+};
+/**
+ * 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>;
+/**
+ * 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;
+};
+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
+     */
+    status: SyncListResponseStatus;
+    /**
+     * Unique identifier for the project.
+     */
+    projectId: string;
+    /**
+     * Target platform for the deployment
+     */
+    platform: SyncListResponsePlatform;
+    /**
+     * DeploymentState protocol version owned by the runtime/manager
+     */
+    deploymentProtocolVersion: number;
+    /**
+     * ID of deployment group this deployment belongs to
+     */
+    deploymentGroupId: string;
+    /**
+     * 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;
+    /**
+     * Setup source that imported this deployment
+     */
+    importSource?: SyncListResponseImportSource | 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;
+    /**
+     * 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;
+    createdAt: Date;
+    updatedAt: Date;
+    /**
+     * ID of the manager responsible for this deployment
+     */
+    managerId?: string | null | undefined;
+    /**
+     * 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 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 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 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 SyncListResponseDeleteScopeEnum$inboundSchema: z.ZodEnum<typeof SyncListResponseDeleteScopeEnum>;
+/** @internal */
+export declare const SyncListResponseDeleteScopeUnion$inboundSchema: z.ZodType<SyncListResponseDeleteScopeUnion, unknown>;
+export declare function syncListResponseDeleteScopeUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseDeleteScopeUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponsePendingDeleteScopeEnum$inboundSchema: z.ZodEnum<typeof SyncListResponsePendingDeleteScopeEnum>;
+/** @internal */
+export declare const SyncListResponsePendingDeleteScopeUnion$inboundSchema: z.ZodType<SyncListResponsePendingDeleteScopeUnion, unknown>;
+export declare function syncListResponsePendingDeleteScopeUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponsePendingDeleteScopeUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseManagementEnum$inboundSchema: z.ZodEnum<typeof SyncListResponseManagementEnum>;
+/** @internal */
+export declare const SyncListResponseOverrideAwResource$inboundSchema: z.ZodType<SyncListResponseOverrideAwResource, unknown>;
+export declare function syncListResponseOverrideAwResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideAwResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideAwStack$inboundSchema: z.ZodType<SyncListResponseOverrideAwStack, unknown>;
+export declare function syncListResponseOverrideAwStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideAwStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideAwBinding$inboundSchema: z.ZodType<SyncListResponseOverrideAwBinding, unknown>;
+export declare function syncListResponseOverrideAwBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideAwBinding, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideEffect$inboundSchema: z.ZodEnum<typeof SyncListResponseOverrideEffect>;
+/** @internal */
+export declare const SyncListResponseOverrideAwGrant$inboundSchema: z.ZodType<SyncListResponseOverrideAwGrant, unknown>;
+export declare function syncListResponseOverrideAwGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideAwGrant, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideAw$inboundSchema: z.ZodType<SyncListResponseOverrideAw, unknown>;
+export declare function syncListResponseOverrideAwFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideAw, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideAzureResource$inboundSchema: z.ZodType<SyncListResponseOverrideAzureResource, unknown>;
+export declare function syncListResponseOverrideAzureResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideAzureResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideAzureStack$inboundSchema: z.ZodType<SyncListResponseOverrideAzureStack, unknown>;
+export declare function syncListResponseOverrideAzureStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideAzureStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideAzureBinding$inboundSchema: z.ZodType<SyncListResponseOverrideAzureBinding, unknown>;
+export declare function syncListResponseOverrideAzureBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideAzureBinding, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideAzureGrant$inboundSchema: z.ZodType<SyncListResponseOverrideAzureGrant, unknown>;
+export declare function syncListResponseOverrideAzureGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideAzureGrant, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideAzure$inboundSchema: z.ZodType<SyncListResponseOverrideAzure, unknown>;
+export declare function syncListResponseOverrideAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideAzure, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideConditionResource$inboundSchema: z.ZodType<SyncListResponseOverrideConditionResource, unknown>;
+export declare function syncListResponseOverrideConditionResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideConditionResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideResourceConditionUnion$inboundSchema: z.ZodType<SyncListResponseOverrideResourceConditionUnion, unknown>;
+export declare function syncListResponseOverrideResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideResourceConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideGcpResource$inboundSchema: z.ZodType<SyncListResponseOverrideGcpResource, unknown>;
+export declare function syncListResponseOverrideGcpResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideGcpResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideConditionStack$inboundSchema: z.ZodType<SyncListResponseOverrideConditionStack, unknown>;
+export declare function syncListResponseOverrideConditionStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideConditionStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideStackConditionUnion$inboundSchema: z.ZodType<SyncListResponseOverrideStackConditionUnion, unknown>;
+export declare function syncListResponseOverrideStackConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideStackConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideGcpStack$inboundSchema: z.ZodType<SyncListResponseOverrideGcpStack, unknown>;
+export declare function syncListResponseOverrideGcpStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideGcpStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideGcpBinding$inboundSchema: z.ZodType<SyncListResponseOverrideGcpBinding, unknown>;
+export declare function syncListResponseOverrideGcpBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideGcpBinding, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideGcpGrant$inboundSchema: z.ZodType<SyncListResponseOverrideGcpGrant, unknown>;
+export declare function syncListResponseOverrideGcpGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideGcpGrant, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideGcp$inboundSchema: z.ZodType<SyncListResponseOverrideGcp, unknown>;
+export declare function syncListResponseOverrideGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideGcp, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverridePlatforms$inboundSchema: z.ZodType<SyncListResponseOverridePlatforms, unknown>;
+export declare function syncListResponseOverridePlatformsFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverridePlatforms, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverride$inboundSchema: z.ZodType<SyncListResponseOverride, unknown>;
+export declare function syncListResponseOverrideFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverride, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseOverrideUnion$inboundSchema: z.ZodType<SyncListResponseOverrideUnion, unknown>;
+export declare function syncListResponseOverrideUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseOverrideUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseManagement2$inboundSchema: z.ZodType<SyncListResponseManagement2, unknown>;
+export declare function syncListResponseManagement2FromJSON(jsonString: string): SafeParseResult<SyncListResponseManagement2, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendAwResource$inboundSchema: z.ZodType<SyncListResponseExtendAwResource, unknown>;
+export declare function syncListResponseExtendAwResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendAwResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendAwStack$inboundSchema: z.ZodType<SyncListResponseExtendAwStack, unknown>;
+export declare function syncListResponseExtendAwStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendAwStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendAwBinding$inboundSchema: z.ZodType<SyncListResponseExtendAwBinding, unknown>;
+export declare function syncListResponseExtendAwBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendAwBinding, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendEffect$inboundSchema: z.ZodEnum<typeof SyncListResponseExtendEffect>;
+/** @internal */
+export declare const SyncListResponseExtendAwGrant$inboundSchema: z.ZodType<SyncListResponseExtendAwGrant, unknown>;
+export declare function syncListResponseExtendAwGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendAwGrant, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendAw$inboundSchema: z.ZodType<SyncListResponseExtendAw, unknown>;
+export declare function syncListResponseExtendAwFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendAw, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendAzureResource$inboundSchema: z.ZodType<SyncListResponseExtendAzureResource, unknown>;
+export declare function syncListResponseExtendAzureResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendAzureResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendAzureStack$inboundSchema: z.ZodType<SyncListResponseExtendAzureStack, unknown>;
+export declare function syncListResponseExtendAzureStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendAzureStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendAzureBinding$inboundSchema: z.ZodType<SyncListResponseExtendAzureBinding, unknown>;
+export declare function syncListResponseExtendAzureBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendAzureBinding, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendAzureGrant$inboundSchema: z.ZodType<SyncListResponseExtendAzureGrant, unknown>;
+export declare function syncListResponseExtendAzureGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendAzureGrant, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendAzure$inboundSchema: z.ZodType<SyncListResponseExtendAzure, unknown>;
+export declare function syncListResponseExtendAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendAzure, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendConditionResource$inboundSchema: z.ZodType<SyncListResponseExtendConditionResource, unknown>;
+export declare function syncListResponseExtendConditionResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendConditionResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendResourceConditionUnion$inboundSchema: z.ZodType<SyncListResponseExtendResourceConditionUnion, unknown>;
+export declare function syncListResponseExtendResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendResourceConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendGcpResource$inboundSchema: z.ZodType<SyncListResponseExtendGcpResource, unknown>;
+export declare function syncListResponseExtendGcpResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendGcpResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendConditionStack$inboundSchema: z.ZodType<SyncListResponseExtendConditionStack, unknown>;
+export declare function syncListResponseExtendConditionStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendConditionStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendStackConditionUnion$inboundSchema: z.ZodType<SyncListResponseExtendStackConditionUnion, unknown>;
+export declare function syncListResponseExtendStackConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendStackConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendGcpStack$inboundSchema: z.ZodType<SyncListResponseExtendGcpStack, unknown>;
+export declare function syncListResponseExtendGcpStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendGcpStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendGcpBinding$inboundSchema: z.ZodType<SyncListResponseExtendGcpBinding, unknown>;
+export declare function syncListResponseExtendGcpBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendGcpBinding, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendGcpGrant$inboundSchema: z.ZodType<SyncListResponseExtendGcpGrant, unknown>;
+export declare function syncListResponseExtendGcpGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendGcpGrant, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendGcp$inboundSchema: z.ZodType<SyncListResponseExtendGcp, unknown>;
+export declare function syncListResponseExtendGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendGcp, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendPlatforms$inboundSchema: z.ZodType<SyncListResponseExtendPlatforms, unknown>;
+export declare function syncListResponseExtendPlatformsFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendPlatforms, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtend$inboundSchema: z.ZodType<SyncListResponseExtend, unknown>;
+export declare function syncListResponseExtendFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtend, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseExtendUnion$inboundSchema: z.ZodType<SyncListResponseExtendUnion, unknown>;
+export declare function syncListResponseExtendUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseExtendUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseManagement1$inboundSchema: z.ZodType<SyncListResponseManagement1, unknown>;
+export declare function syncListResponseManagement1FromJSON(jsonString: string): SafeParseResult<SyncListResponseManagement1, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseManagementUnion$inboundSchema: z.ZodType<SyncListResponseManagementUnion, unknown>;
+export declare function syncListResponseManagementUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseManagementUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileAwResource$inboundSchema: z.ZodType<SyncListResponseProfileAwResource, unknown>;
+export declare function syncListResponseProfileAwResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileAwResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileAwStack$inboundSchema: z.ZodType<SyncListResponseProfileAwStack, unknown>;
+export declare function syncListResponseProfileAwStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileAwStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileAwBinding$inboundSchema: z.ZodType<SyncListResponseProfileAwBinding, unknown>;
+export declare function syncListResponseProfileAwBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileAwBinding, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileEffect$inboundSchema: z.ZodEnum<typeof SyncListResponseProfileEffect>;
+/** @internal */
+export declare const SyncListResponseProfileAwGrant$inboundSchema: z.ZodType<SyncListResponseProfileAwGrant, unknown>;
+export declare function syncListResponseProfileAwGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileAwGrant, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileAw$inboundSchema: z.ZodType<SyncListResponseProfileAw, unknown>;
+export declare function syncListResponseProfileAwFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileAw, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileAzureResource$inboundSchema: z.ZodType<SyncListResponseProfileAzureResource, unknown>;
+export declare function syncListResponseProfileAzureResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileAzureResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileAzureStack$inboundSchema: z.ZodType<SyncListResponseProfileAzureStack, unknown>;
+export declare function syncListResponseProfileAzureStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileAzureStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileAzureBinding$inboundSchema: z.ZodType<SyncListResponseProfileAzureBinding, unknown>;
+export declare function syncListResponseProfileAzureBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileAzureBinding, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileAzureGrant$inboundSchema: z.ZodType<SyncListResponseProfileAzureGrant, unknown>;
+export declare function syncListResponseProfileAzureGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileAzureGrant, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileAzure$inboundSchema: z.ZodType<SyncListResponseProfileAzure, unknown>;
+export declare function syncListResponseProfileAzureFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileAzure, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileConditionResource$inboundSchema: z.ZodType<SyncListResponseProfileConditionResource, unknown>;
+export declare function syncListResponseProfileConditionResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileConditionResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileResourceConditionUnion$inboundSchema: z.ZodType<SyncListResponseProfileResourceConditionUnion, unknown>;
+export declare function syncListResponseProfileResourceConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileResourceConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileGcpResource$inboundSchema: z.ZodType<SyncListResponseProfileGcpResource, unknown>;
+export declare function syncListResponseProfileGcpResourceFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileGcpResource, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileConditionStack$inboundSchema: z.ZodType<SyncListResponseProfileConditionStack, unknown>;
+export declare function syncListResponseProfileConditionStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileConditionStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileStackConditionUnion$inboundSchema: z.ZodType<SyncListResponseProfileStackConditionUnion, unknown>;
+export declare function syncListResponseProfileStackConditionUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileStackConditionUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileGcpStack$inboundSchema: z.ZodType<SyncListResponseProfileGcpStack, unknown>;
+export declare function syncListResponseProfileGcpStackFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileGcpStack, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileGcpBinding$inboundSchema: z.ZodType<SyncListResponseProfileGcpBinding, unknown>;
+export declare function syncListResponseProfileGcpBindingFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileGcpBinding, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileGcpGrant$inboundSchema: z.ZodType<SyncListResponseProfileGcpGrant, unknown>;
+export declare function syncListResponseProfileGcpGrantFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileGcpGrant, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileGcp$inboundSchema: z.ZodType<SyncListResponseProfileGcp, unknown>;
+export declare function syncListResponseProfileGcpFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileGcp, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfilePlatforms$inboundSchema: z.ZodType<SyncListResponseProfilePlatforms, unknown>;
+export declare function syncListResponseProfilePlatformsFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfilePlatforms, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfile$inboundSchema: z.ZodType<SyncListResponseProfile, unknown>;
+export declare function syncListResponseProfileFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfile, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponseProfileUnion$inboundSchema: z.ZodType<SyncListResponseProfileUnion, unknown>;
+export declare function syncListResponseProfileUnionFromJSON(jsonString: string): SafeParseResult<SyncListResponseProfileUnion, SDKValidationError>;
+/** @internal */
+export declare const SyncListResponsePermissions$inboundSchema: z.ZodType<SyncListResponsePermissions, unknown>;
+export declare function syncListResponsePermissionsFromJSON(jsonString: string): SafeParseResult<SyncListResponsePermissions, 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 SyncListResponseSupportedPlatform$inboundSchema: z.ZodEnum<typeof SyncListResponseSupportedPlatform>;
+/** @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 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 SyncListResponseError$inboundSchema: z.ZodType<SyncListResponseError, unknown>;
+export declare function syncListResponseErrorFromJSON(jsonString: string): SafeParseResult<SyncListResponseError, 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