@alienplatform/platform-api 1.3.4 → 1.4.0

package/esm/models/operations/preparedeploymentstack.d.ts

@@ -0,0 +1,1435 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../../types/enums.js";
+import * as models from "../index.js";
+export declare const PrepareDeploymentStackPlatform: {
+    readonly Aws: "aws";
+    readonly Gcp: "gcp";
+    readonly Azure: "azure";
+};
+export type PrepareDeploymentStackPlatform = ClosedEnum<typeof PrepareDeploymentStackPlatform>;
+/**
+ * Deployment model: how updates are delivered to the remote environment.
+ */
+export declare const DeploymentModel: {
+    readonly Push: "push";
+    readonly Pull: "pull";
+};
+/**
+ * Deployment model: how updates are delivered to the remote environment.
+ */
+export type DeploymentModel = ClosedEnum<typeof DeploymentModel>;
+export type PrepareDeploymentStackAws = {
+    certificateArn: string;
+};
+export type Aws = PrepareDeploymentStackAws | any;
+export type PrepareDeploymentStackAzure = {
+    keyVaultCertificateId: string;
+};
+export type Azure = PrepareDeploymentStackAzure | any;
+export type PrepareDeploymentStackGcp = {
+    certificateName: string;
+};
+export type Gcp = PrepareDeploymentStackGcp | any;
+/**
+ * Namespace-scoped Kubernetes TLS Secret reference.
+ */
+export type TlsSecretRef = {
+    /**
+     * Secret namespace. Defaults to the release namespace when omitted.
+     */
+    namespace?: string | null | undefined;
+    /**
+     * Secret name.
+     */
+    secretName: string;
+};
+export type DomainsKubernetes = {
+    /**
+     * Namespace-scoped Kubernetes TLS Secret reference.
+     */
+    tlsSecretRef: TlsSecretRef;
+};
+export type DomainsKubernetesUnion = DomainsKubernetes | any;
+/**
+ * Platform-specific certificate references for custom domains.
+ */
+export type DomainsCertificate = {
+    aws?: PrepareDeploymentStackAws | any | null | undefined;
+    azure?: PrepareDeploymentStackAzure | any | null | undefined;
+    gcp?: PrepareDeploymentStackGcp | any | null | undefined;
+    kubernetes?: DomainsKubernetes | any | null | undefined;
+};
+/**
+ * Custom domain configuration for a single resource.
+ */
+export type CustomDomains = {
+    /**
+     * Platform-specific certificate references for custom domains.
+     */
+    certificate: DomainsCertificate;
+    /**
+     * 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 Domains = {
+    /**
+     * Custom domain configuration per resource ID.
+     */
+    customDomains?: {
+        [k: string]: CustomDomains;
+    } | null | undefined;
+};
+export type DomainsUnion = Domains | 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 ExternalBindings = {};
+/**
+ * How heartbeat health checks are handled.
+ */
+export declare const Heartbeats: {
+    readonly Off: "off";
+    readonly On: "on";
+};
+/**
+ * How heartbeat health checks are handled.
+ */
+export type Heartbeats = ClosedEnum<typeof Heartbeats>;
+/**
+ * Optional provider-specific identity for a cloud-backed Kubernetes cluster.
+ */
+export type Cloud = {
+    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 CloudUnion = Cloud | any;
+/**
+ * Ownership model for the Kubernetes cluster.
+ */
+export declare const Ownership: {
+    readonly Managed: "managed";
+    readonly Existing: "existing";
+    readonly External: "external";
+};
+/**
+ * Ownership model for the Kubernetes cluster.
+ */
+export type Ownership = ClosedEnum<typeof Ownership>;
+/**
+ * Kubernetes cluster setup settings.
+ */
+export type Cluster = {
+    cloud?: Cloud | any | null | undefined;
+    /**
+     * Namespace where the Alien chart and application resources run.
+     */
+    namespace?: string | null | undefined;
+    /**
+     * Ownership model for the Kubernetes cluster.
+     */
+    ownership: Ownership;
+};
+export type ClusterUnion = Cluster | any;
+export type CertificateNone2 = {
+    mode: "none";
+};
+export type CertificateManagedTLSSecret2 = {
+    mode: "managedTlsSecret";
+    /**
+     * Secret name template. Runtime may substitute resource/deployment tokens.
+     */
+    secretNameTemplate: string;
+};
+export type CertificateAwsAcmArn2 = {
+    /**
+     * Existing ACM certificate ARN.
+     */
+    certificateArn: string;
+    mode: "awsAcmArn";
+};
+export type CertificateManagedAcmImport2 = {
+    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 CertificateTLSSecretRef2 = {
+    /**
+     * 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 CertificateUnion2 = CertificateTLSSecretRef2 | CertificateManagedAcmImport2 | CertificateAwsAcmArn2 | CertificateManagedTLSSecret2 | CertificateNone2;
+export declare const ModeCustom: {
+    readonly Custom: "custom";
+};
+export type ModeCustom = ClosedEnum<typeof ModeCustom>;
+export declare const ProviderAzureApplicationGatewayForContainersEnum4: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type ProviderAzureApplicationGatewayForContainersEnum4 = ClosedEnum<typeof ProviderAzureApplicationGatewayForContainersEnum4>;
+export type ProviderAzureApplicationGatewayForContainers4 = {
+    /**
+     * 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: ProviderAzureApplicationGatewayForContainersEnum4;
+};
+export declare const ProviderGkeGatewayEnum4: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type ProviderGkeGatewayEnum4 = ClosedEnum<typeof ProviderGkeGatewayEnum4>;
+export type ProviderGkeGateway4 = {
+    provider: ProviderGkeGatewayEnum4;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const ProviderAwsAlbEnum4: {
+    readonly AwsAlb: "awsAlb";
+};
+export type ProviderAwsAlbEnum4 = ClosedEnum<typeof ProviderAwsAlbEnum4>;
+export type ProviderAwsAlb4 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: ProviderAwsAlbEnum4;
+    /**
+     * 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 ProviderUnion4 = ProviderAwsAlb4 | ProviderAzureApplicationGatewayForContainers4 | ProviderGkeGateway4 | any;
+/**
+ * Shared Gateway API route profile values.
+ */
+export type RouteGateway2 = {
+    /**
+     * 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?: ProviderAwsAlb4 | ProviderAzureApplicationGatewayForContainers4 | ProviderGkeGateway4 | any | null | undefined;
+    routeApi: "gateway";
+};
+export declare const ProviderAzureApplicationGatewayForContainersEnum3: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type ProviderAzureApplicationGatewayForContainersEnum3 = ClosedEnum<typeof ProviderAzureApplicationGatewayForContainersEnum3>;
+export type ProviderAzureApplicationGatewayForContainers3 = {
+    /**
+     * 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: ProviderAzureApplicationGatewayForContainersEnum3;
+};
+export declare const ProviderGkeGatewayEnum3: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type ProviderGkeGatewayEnum3 = ClosedEnum<typeof ProviderGkeGatewayEnum3>;
+export type ProviderGkeGateway3 = {
+    provider: ProviderGkeGatewayEnum3;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const ProviderAwsAlbEnum3: {
+    readonly AwsAlb: "awsAlb";
+};
+export type ProviderAwsAlbEnum3 = ClosedEnum<typeof ProviderAwsAlbEnum3>;
+export type ProviderAwsAlb3 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: ProviderAwsAlbEnum3;
+    /**
+     * 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 ProviderUnion3 = ProviderAwsAlb3 | ProviderAzureApplicationGatewayForContainers3 | ProviderGkeGateway3 | any;
+/**
+ * Shared Ingress route profile values.
+ */
+export type RouteIngress2 = {
+    /**
+     * 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?: ProviderAwsAlb3 | ProviderAzureApplicationGatewayForContainers3 | ProviderGkeGateway3 | any | null | undefined;
+    routeApi: "ingress";
+};
+/**
+ * Kubernetes route API selected for public endpoints.
+ */
+export type RouteUnion2 = RouteIngress2 | RouteGateway2;
+export type ExposureCustom = {
+    /**
+     * Certificate publication or reference mode for Kubernetes public endpoints.
+     */
+    certificate: CertificateTLSSecretRef2 | CertificateManagedAcmImport2 | CertificateAwsAcmArn2 | CertificateManagedTLSSecret2 | CertificateNone2;
+    /**
+     * Hostname routed by the Kubernetes public endpoint.
+     */
+    domain: string;
+    mode: ModeCustom;
+    /**
+     * Kubernetes route API selected for public endpoints.
+     */
+    route: RouteIngress2 | RouteGateway2;
+};
+export type CertificateNone1 = {
+    mode: "none";
+};
+export type CertificateManagedTLSSecret1 = {
+    mode: "managedTlsSecret";
+    /**
+     * Secret name template. Runtime may substitute resource/deployment tokens.
+     */
+    secretNameTemplate: string;
+};
+export type CertificateAwsAcmArn1 = {
+    /**
+     * Existing ACM certificate ARN.
+     */
+    certificateArn: string;
+    mode: "awsAcmArn";
+};
+export type CertificateManagedAcmImport1 = {
+    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 CertificateTLSSecretRef1 = {
+    /**
+     * 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 CertificateUnion1 = CertificateTLSSecretRef1 | CertificateManagedAcmImport1 | CertificateAwsAcmArn1 | CertificateManagedTLSSecret1 | CertificateNone1;
+export declare const ModeGenerated: {
+    readonly Generated: "generated";
+};
+export type ModeGenerated = ClosedEnum<typeof ModeGenerated>;
+export declare const ProviderAzureApplicationGatewayForContainersEnum2: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type ProviderAzureApplicationGatewayForContainersEnum2 = ClosedEnum<typeof ProviderAzureApplicationGatewayForContainersEnum2>;
+export type ProviderAzureApplicationGatewayForContainers2 = {
+    /**
+     * 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: ProviderAzureApplicationGatewayForContainersEnum2;
+};
+export declare const ProviderGkeGatewayEnum2: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type ProviderGkeGatewayEnum2 = ClosedEnum<typeof ProviderGkeGatewayEnum2>;
+export type ProviderGkeGateway2 = {
+    provider: ProviderGkeGatewayEnum2;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const ProviderAwsAlbEnum2: {
+    readonly AwsAlb: "awsAlb";
+};
+export type ProviderAwsAlbEnum2 = ClosedEnum<typeof ProviderAwsAlbEnum2>;
+export type ProviderAwsAlb2 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: ProviderAwsAlbEnum2;
+    /**
+     * 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 ProviderUnion2 = ProviderAwsAlb2 | ProviderAzureApplicationGatewayForContainers2 | ProviderGkeGateway2 | any;
+/**
+ * Shared Gateway API route profile values.
+ */
+export type RouteGateway1 = {
+    /**
+     * 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?: ProviderAwsAlb2 | ProviderAzureApplicationGatewayForContainers2 | ProviderGkeGateway2 | any | null | undefined;
+    routeApi: "gateway";
+};
+export declare const ProviderAzureApplicationGatewayForContainersEnum1: {
+    readonly AzureApplicationGatewayForContainers: "azureApplicationGatewayForContainers";
+};
+export type ProviderAzureApplicationGatewayForContainersEnum1 = ClosedEnum<typeof ProviderAzureApplicationGatewayForContainersEnum1>;
+export type ProviderAzureApplicationGatewayForContainers1 = {
+    /**
+     * 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: ProviderAzureApplicationGatewayForContainersEnum1;
+};
+export declare const ProviderGkeGatewayEnum1: {
+    readonly GkeGateway: "gkeGateway";
+};
+export type ProviderGkeGatewayEnum1 = ClosedEnum<typeof ProviderGkeGatewayEnum1>;
+export type ProviderGkeGateway1 = {
+    provider: ProviderGkeGatewayEnum1;
+    /**
+     * Optional static address name for the Gateway frontend.
+     */
+    staticAddressName?: string | null | undefined;
+};
+export declare const ProviderAwsAlbEnum1: {
+    readonly AwsAlb: "awsAlb";
+};
+export type ProviderAwsAlbEnum1 = ClosedEnum<typeof ProviderAwsAlbEnum1>;
+export type ProviderAwsAlb1 = {
+    /**
+     * Optional ALB IP address type, such as `dualstack`.
+     */
+    ipAddressType?: string | null | undefined;
+    provider: ProviderAwsAlbEnum1;
+    /**
+     * 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 ProviderUnion1 = ProviderAwsAlb1 | ProviderAzureApplicationGatewayForContainers1 | ProviderGkeGateway1 | any;
+/**
+ * Shared Ingress route profile values.
+ */
+export type RouteIngress1 = {
+    /**
+     * 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?: ProviderAwsAlb1 | ProviderAzureApplicationGatewayForContainers1 | ProviderGkeGateway1 | any | null | undefined;
+    routeApi: "ingress";
+};
+/**
+ * Kubernetes route API selected for public endpoints.
+ */
+export type RouteUnion1 = RouteIngress1 | RouteGateway1;
+export type ExposureGenerated = {
+    /**
+     * Certificate publication or reference mode for Kubernetes public endpoints.
+     */
+    certificate: CertificateTLSSecretRef1 | CertificateManagedAcmImport1 | CertificateAwsAcmArn1 | CertificateManagedTLSSecret1 | CertificateNone1;
+    mode: ModeGenerated;
+    /**
+     * Kubernetes route API selected for public endpoints.
+     */
+    route: RouteIngress1 | RouteGateway1;
+};
+export declare const ModeDisabled: {
+    readonly Disabled: "disabled";
+};
+export type ModeDisabled = ClosedEnum<typeof ModeDisabled>;
+export type ExposureDisabled = {
+    mode: ModeDisabled;
+};
+export type Exposure = ExposureCustom | ExposureGenerated | ExposureDisabled | 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 PrepareDeploymentStackKubernetes = {
+    cluster?: Cluster | any | null | undefined;
+    exposure?: ExposureCustom | ExposureGenerated | ExposureDisabled | any | null | undefined;
+};
+export type Kubernetes = PrepareDeploymentStackKubernetes | any;
+export declare const TypeByoVnetAzure: {
+    readonly ByoVnetAzure: "byo-vnet-azure";
+};
+export type TypeByoVnetAzure = ClosedEnum<typeof TypeByoVnetAzure>;
+export type NetworkByoVnetAzure = {
+    /**
+     * Name of the private subnet within the VNet
+     */
+    privateSubnetName: string;
+    /**
+     * Name of the public subnet within the VNet
+     */
+    publicSubnetName: string;
+    type: TypeByoVnetAzure;
+    /**
+     * The full resource ID of the existing VNet
+     */
+    vnetResourceId: string;
+};
+export declare const TypeByoVpcGcp: {
+    readonly ByoVpcGcp: "byo-vpc-gcp";
+};
+export type TypeByoVpcGcp = ClosedEnum<typeof TypeByoVpcGcp>;
+export type NetworkByoVpcGcp = {
+    /**
+     * 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: TypeByoVpcGcp;
+};
+export declare const TypeByoVpcAws: {
+    readonly ByoVpcAws: "byo-vpc-aws";
+};
+export type TypeByoVpcAws = ClosedEnum<typeof TypeByoVpcAws>;
+export type NetworkByoVpcAws = {
+    /**
+     * 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: TypeByoVpcAws;
+    /**
+     * The ID of the existing VPC
+     */
+    vpcId: string;
+};
+export declare const TypeCreate: {
+    readonly Create: "create";
+};
+export type TypeCreate = ClosedEnum<typeof TypeCreate>;
+export type NetworkCreate = {
+    /**
+     * 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: TypeCreate;
+};
+export declare const TypeUseDefault: {
+    readonly UseDefault: "use-default";
+};
+export type TypeUseDefault = ClosedEnum<typeof TypeUseDefault>;
+export type NetworkUseDefault = {
+    type: TypeUseDefault;
+};
+export type Network = NetworkByoVpcAws | NetworkByoVpcGcp | NetworkByoVnetAzure | NetworkUseDefault | NetworkCreate | any;
+/**
+ * How telemetry (logs, metrics, traces) is handled.
+ */
+export declare const Telemetry: {
+    readonly Off: "off";
+    readonly Auto: "auto";
+    readonly ApprovalRequired: "approval-required";
+};
+/**
+ * How telemetry (logs, metrics, traces) is handled.
+ */
+export type Telemetry = ClosedEnum<typeof Telemetry>;
+/**
+ * How updates are delivered to the deployment.
+ */
+export declare const Updates: {
+    readonly Auto: "auto";
+    readonly ApprovalRequired: "approval-required";
+};
+/**
+ * How updates are delivered to the deployment.
+ */
+export type Updates = ClosedEnum<typeof Updates>;
+/**
+ * User-customizable deployment settings specified at deploy time.
+ *
+ * @remarks
+ *
+ * These settings are provided by the customer via CloudFormation parameters,
+ * Terraform attributes, CLI flags, or Helm values. They customize how the
+ * deployment runs and what capabilities are enabled.
+ *
+ * **Key distinction**: StackSettings is user-customizable, while ManagementConfig
+ * is platform-derived (from the Manager's ServiceAccount).
+ */
+export type StackSettings = {
+    /**
+     * Deployment model: how updates are delivered to the remote environment.
+     */
+    deploymentModel?: DeploymentModel | undefined;
+    domains?: Domains | 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?: ExternalBindings | null | undefined;
+    /**
+     * How heartbeat health checks are handled.
+     */
+    heartbeats?: Heartbeats | undefined;
+    kubernetes?: PrepareDeploymentStackKubernetes | any | null | undefined;
+    network?: NetworkByoVpcAws | NetworkByoVpcGcp | NetworkByoVnetAzure | NetworkUseDefault | NetworkCreate | any | null | undefined;
+    /**
+     * How telemetry (logs, metrics, traces) is handled.
+     */
+    telemetry?: Telemetry | undefined;
+    /**
+     * How updates are delivered to the deployment.
+     */
+    updates?: Updates | undefined;
+};
+export type PrepareDeploymentStackRequestBody = {
+    platform: PrepareDeploymentStackPlatform;
+    setupMethod: models.DeploymentSetupMethod;
+    region?: string | undefined;
+    /**
+     * User-customizable deployment settings specified at deploy time.
+     *
+     * @remarks
+     *
+     * These settings are provided by the customer via CloudFormation parameters,
+     * Terraform attributes, CLI flags, or Helm values. They customize how the
+     * deployment runs and what capabilities are enabled.
+     *
+     * **Key distinction**: StackSettings is user-customizable, while ManagementConfig
+     * is platform-derived (from the Manager's ServiceAccount).
+     */
+    stackSettings: StackSettings;
+};
+export type PrepareDeploymentStackRequest = {
+    /**
+     * Workspace name. Defaults to your last workspace (user auth) or your API key's workspace (token auth). When using an API key, if provided, must match the key's workspace.
+     */
+    workspace?: string | undefined;
+    requestBody?: PrepareDeploymentStackRequestBody | undefined;
+};
+/** @internal */
+export declare const PrepareDeploymentStackPlatform$outboundSchema: z.ZodEnum<typeof PrepareDeploymentStackPlatform>;
+/** @internal */
+export declare const DeploymentModel$outboundSchema: z.ZodEnum<typeof DeploymentModel>;
+/** @internal */
+export type PrepareDeploymentStackAws$Outbound = {
+    certificateArn: string;
+};
+/** @internal */
+export declare const PrepareDeploymentStackAws$outboundSchema: z.ZodType<PrepareDeploymentStackAws$Outbound, PrepareDeploymentStackAws>;
+export declare function prepareDeploymentStackAwsToJSON(prepareDeploymentStackAws: PrepareDeploymentStackAws): string;
+/** @internal */
+export type Aws$Outbound = PrepareDeploymentStackAws$Outbound | any;
+/** @internal */
+export declare const Aws$outboundSchema: z.ZodType<Aws$Outbound, Aws>;
+export declare function awsToJSON(aws: Aws): string;
+/** @internal */
+export type PrepareDeploymentStackAzure$Outbound = {
+    keyVaultCertificateId: string;
+};
+/** @internal */
+export declare const PrepareDeploymentStackAzure$outboundSchema: z.ZodType<PrepareDeploymentStackAzure$Outbound, PrepareDeploymentStackAzure>;
+export declare function prepareDeploymentStackAzureToJSON(prepareDeploymentStackAzure: PrepareDeploymentStackAzure): string;
+/** @internal */
+export type Azure$Outbound = PrepareDeploymentStackAzure$Outbound | any;
+/** @internal */
+export declare const Azure$outboundSchema: z.ZodType<Azure$Outbound, Azure>;
+export declare function azureToJSON(azure: Azure): string;
+/** @internal */
+export type PrepareDeploymentStackGcp$Outbound = {
+    certificateName: string;
+};
+/** @internal */
+export declare const PrepareDeploymentStackGcp$outboundSchema: z.ZodType<PrepareDeploymentStackGcp$Outbound, PrepareDeploymentStackGcp>;
+export declare function prepareDeploymentStackGcpToJSON(prepareDeploymentStackGcp: PrepareDeploymentStackGcp): string;
+/** @internal */
+export type Gcp$Outbound = PrepareDeploymentStackGcp$Outbound | any;
+/** @internal */
+export declare const Gcp$outboundSchema: z.ZodType<Gcp$Outbound, Gcp>;
+export declare function gcpToJSON(gcp: Gcp): string;
+/** @internal */
+export type TlsSecretRef$Outbound = {
+    namespace?: string | null | undefined;
+    secretName: string;
+};
+/** @internal */
+export declare const TlsSecretRef$outboundSchema: z.ZodType<TlsSecretRef$Outbound, TlsSecretRef>;
+export declare function tlsSecretRefToJSON(tlsSecretRef: TlsSecretRef): string;
+/** @internal */
+export type DomainsKubernetes$Outbound = {
+    tlsSecretRef: TlsSecretRef$Outbound;
+};
+/** @internal */
+export declare const DomainsKubernetes$outboundSchema: z.ZodType<DomainsKubernetes$Outbound, DomainsKubernetes>;
+export declare function domainsKubernetesToJSON(domainsKubernetes: DomainsKubernetes): string;
+/** @internal */
+export type DomainsKubernetesUnion$Outbound = DomainsKubernetes$Outbound | any;
+/** @internal */
+export declare const DomainsKubernetesUnion$outboundSchema: z.ZodType<DomainsKubernetesUnion$Outbound, DomainsKubernetesUnion>;
+export declare function domainsKubernetesUnionToJSON(domainsKubernetesUnion: DomainsKubernetesUnion): string;
+/** @internal */
+export type DomainsCertificate$Outbound = {
+    aws?: PrepareDeploymentStackAws$Outbound | any | null | undefined;
+    azure?: PrepareDeploymentStackAzure$Outbound | any | null | undefined;
+    gcp?: PrepareDeploymentStackGcp$Outbound | any | null | undefined;
+    kubernetes?: DomainsKubernetes$Outbound | any | null | undefined;
+};
+/** @internal */
+export declare const DomainsCertificate$outboundSchema: z.ZodType<DomainsCertificate$Outbound, DomainsCertificate>;
+export declare function domainsCertificateToJSON(domainsCertificate: DomainsCertificate): string;
+/** @internal */
+export type CustomDomains$Outbound = {
+    certificate: DomainsCertificate$Outbound;
+    domain: string;
+};
+/** @internal */
+export declare const CustomDomains$outboundSchema: z.ZodType<CustomDomains$Outbound, CustomDomains>;
+export declare function customDomainsToJSON(customDomains: CustomDomains): string;
+/** @internal */
+export type Domains$Outbound = {
+    customDomains?: {
+        [k: string]: CustomDomains$Outbound;
+    } | null | undefined;
+};
+/** @internal */
+export declare const Domains$outboundSchema: z.ZodType<Domains$Outbound, Domains>;
+export declare function domainsToJSON(domains: Domains): string;
+/** @internal */
+export type DomainsUnion$Outbound = Domains$Outbound | any;
+/** @internal */
+export declare const DomainsUnion$outboundSchema: z.ZodType<DomainsUnion$Outbound, DomainsUnion>;
+export declare function domainsUnionToJSON(domainsUnion: DomainsUnion): string;
+/** @internal */
+export type ExternalBindings$Outbound = {};
+/** @internal */
+export declare const ExternalBindings$outboundSchema: z.ZodType<ExternalBindings$Outbound, ExternalBindings>;
+export declare function externalBindingsToJSON(externalBindings: ExternalBindings): string;
+/** @internal */
+export declare const Heartbeats$outboundSchema: z.ZodEnum<typeof Heartbeats>;
+/** @internal */
+export type Cloud$Outbound = {
+    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;
+};
+/** @internal */
+export declare const Cloud$outboundSchema: z.ZodType<Cloud$Outbound, Cloud>;
+export declare function cloudToJSON(cloud: Cloud): string;
+/** @internal */
+export type CloudUnion$Outbound = Cloud$Outbound | any;
+/** @internal */
+export declare const CloudUnion$outboundSchema: z.ZodType<CloudUnion$Outbound, CloudUnion>;
+export declare function cloudUnionToJSON(cloudUnion: CloudUnion): string;
+/** @internal */
+export declare const Ownership$outboundSchema: z.ZodEnum<typeof Ownership>;
+/** @internal */
+export type Cluster$Outbound = {
+    cloud?: Cloud$Outbound | any | null | undefined;
+    namespace?: string | null | undefined;
+    ownership: string;
+};
+/** @internal */
+export declare const Cluster$outboundSchema: z.ZodType<Cluster$Outbound, Cluster>;
+export declare function clusterToJSON(cluster: Cluster): string;
+/** @internal */
+export type ClusterUnion$Outbound = Cluster$Outbound | any;
+/** @internal */
+export declare const ClusterUnion$outboundSchema: z.ZodType<ClusterUnion$Outbound, ClusterUnion>;
+export declare function clusterUnionToJSON(clusterUnion: ClusterUnion): string;
+/** @internal */
+export type CertificateNone2$Outbound = {
+    mode: "none";
+};
+/** @internal */
+export declare const CertificateNone2$outboundSchema: z.ZodType<CertificateNone2$Outbound, CertificateNone2>;
+export declare function certificateNone2ToJSON(certificateNone2: CertificateNone2): string;
+/** @internal */
+export type CertificateManagedTLSSecret2$Outbound = {
+    mode: "managedTlsSecret";
+    secretNameTemplate: string;
+};
+/** @internal */
+export declare const CertificateManagedTLSSecret2$outboundSchema: z.ZodType<CertificateManagedTLSSecret2$Outbound, CertificateManagedTLSSecret2>;
+export declare function certificateManagedTLSSecret2ToJSON(certificateManagedTLSSecret2: CertificateManagedTLSSecret2): string;
+/** @internal */
+export type CertificateAwsAcmArn2$Outbound = {
+    certificateArn: string;
+    mode: "awsAcmArn";
+};
+/** @internal */
+export declare const CertificateAwsAcmArn2$outboundSchema: z.ZodType<CertificateAwsAcmArn2$Outbound, CertificateAwsAcmArn2>;
+export declare function certificateAwsAcmArn2ToJSON(certificateAwsAcmArn2: CertificateAwsAcmArn2): string;
+/** @internal */
+export type CertificateManagedAcmImport2$Outbound = {
+    mode: "managedAcmImport";
+    region?: string | null | undefined;
+    tags?: {
+        [k: string]: string;
+    } | undefined;
+};
+/** @internal */
+export declare const CertificateManagedAcmImport2$outboundSchema: z.ZodType<CertificateManagedAcmImport2$Outbound, CertificateManagedAcmImport2>;
+export declare function certificateManagedAcmImport2ToJSON(certificateManagedAcmImport2: CertificateManagedAcmImport2): string;
+/** @internal */
+export type CertificateTLSSecretRef2$Outbound = {
+    namespace?: string | null | undefined;
+    secretName: string;
+    mode: "tlsSecretRef";
+};
+/** @internal */
+export declare const CertificateTLSSecretRef2$outboundSchema: z.ZodType<CertificateTLSSecretRef2$Outbound, CertificateTLSSecretRef2>;
+export declare function certificateTLSSecretRef2ToJSON(certificateTLSSecretRef2: CertificateTLSSecretRef2): string;
+/** @internal */
+export type CertificateUnion2$Outbound = CertificateTLSSecretRef2$Outbound | CertificateManagedAcmImport2$Outbound | CertificateAwsAcmArn2$Outbound | CertificateManagedTLSSecret2$Outbound | CertificateNone2$Outbound;
+/** @internal */
+export declare const CertificateUnion2$outboundSchema: z.ZodType<CertificateUnion2$Outbound, CertificateUnion2>;
+export declare function certificateUnion2ToJSON(certificateUnion2: CertificateUnion2): string;
+/** @internal */
+export declare const ModeCustom$outboundSchema: z.ZodEnum<typeof ModeCustom>;
+/** @internal */
+export declare const ProviderAzureApplicationGatewayForContainersEnum4$outboundSchema: z.ZodEnum<typeof ProviderAzureApplicationGatewayForContainersEnum4>;
+/** @internal */
+export type ProviderAzureApplicationGatewayForContainers4$Outbound = {
+    albName?: string | null | undefined;
+    albNamespace?: string | null | undefined;
+    frontend: string;
+    provider: string;
+};
+/** @internal */
+export declare const ProviderAzureApplicationGatewayForContainers4$outboundSchema: z.ZodType<ProviderAzureApplicationGatewayForContainers4$Outbound, ProviderAzureApplicationGatewayForContainers4>;
+export declare function providerAzureApplicationGatewayForContainers4ToJSON(providerAzureApplicationGatewayForContainers4: ProviderAzureApplicationGatewayForContainers4): string;
+/** @internal */
+export declare const ProviderGkeGatewayEnum4$outboundSchema: z.ZodEnum<typeof ProviderGkeGatewayEnum4>;
+/** @internal */
+export type ProviderGkeGateway4$Outbound = {
+    provider: string;
+    staticAddressName?: string | null | undefined;
+};
+/** @internal */
+export declare const ProviderGkeGateway4$outboundSchema: z.ZodType<ProviderGkeGateway4$Outbound, ProviderGkeGateway4>;
+export declare function providerGkeGateway4ToJSON(providerGkeGateway4: ProviderGkeGateway4): string;
+/** @internal */
+export declare const ProviderAwsAlbEnum4$outboundSchema: z.ZodEnum<typeof ProviderAwsAlbEnum4>;
+/** @internal */
+export type ProviderAwsAlb4$Outbound = {
+    ipAddressType?: string | null | undefined;
+    provider: string;
+    scheme: string;
+    subnetIds?: Array<string> | undefined;
+    targetType: string;
+};
+/** @internal */
+export declare const ProviderAwsAlb4$outboundSchema: z.ZodType<ProviderAwsAlb4$Outbound, ProviderAwsAlb4>;
+export declare function providerAwsAlb4ToJSON(providerAwsAlb4: ProviderAwsAlb4): string;
+/** @internal */
+export type ProviderUnion4$Outbound = ProviderAwsAlb4$Outbound | ProviderAzureApplicationGatewayForContainers4$Outbound | ProviderGkeGateway4$Outbound | any;
+/** @internal */
+export declare const ProviderUnion4$outboundSchema: z.ZodType<ProviderUnion4$Outbound, ProviderUnion4>;
+export declare function providerUnion4ToJSON(providerUnion4: ProviderUnion4): string;
+/** @internal */
+export type RouteGateway2$Outbound = {
+    annotations?: {
+        [k: string]: string;
+    } | undefined;
+    controller?: string | null | undefined;
+    gatewayClassName: string;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    listenerPort: number;
+    provider?: ProviderAwsAlb4$Outbound | ProviderAzureApplicationGatewayForContainers4$Outbound | ProviderGkeGateway4$Outbound | any | null | undefined;
+    routeApi: "gateway";
+};
+/** @internal */
+export declare const RouteGateway2$outboundSchema: z.ZodType<RouteGateway2$Outbound, RouteGateway2>;
+export declare function routeGateway2ToJSON(routeGateway2: RouteGateway2): string;
+/** @internal */
+export declare const ProviderAzureApplicationGatewayForContainersEnum3$outboundSchema: z.ZodEnum<typeof ProviderAzureApplicationGatewayForContainersEnum3>;
+/** @internal */
+export type ProviderAzureApplicationGatewayForContainers3$Outbound = {
+    albName?: string | null | undefined;
+    albNamespace?: string | null | undefined;
+    frontend: string;
+    provider: string;
+};
+/** @internal */
+export declare const ProviderAzureApplicationGatewayForContainers3$outboundSchema: z.ZodType<ProviderAzureApplicationGatewayForContainers3$Outbound, ProviderAzureApplicationGatewayForContainers3>;
+export declare function providerAzureApplicationGatewayForContainers3ToJSON(providerAzureApplicationGatewayForContainers3: ProviderAzureApplicationGatewayForContainers3): string;
+/** @internal */
+export declare const ProviderGkeGatewayEnum3$outboundSchema: z.ZodEnum<typeof ProviderGkeGatewayEnum3>;
+/** @internal */
+export type ProviderGkeGateway3$Outbound = {
+    provider: string;
+    staticAddressName?: string | null | undefined;
+};
+/** @internal */
+export declare const ProviderGkeGateway3$outboundSchema: z.ZodType<ProviderGkeGateway3$Outbound, ProviderGkeGateway3>;
+export declare function providerGkeGateway3ToJSON(providerGkeGateway3: ProviderGkeGateway3): string;
+/** @internal */
+export declare const ProviderAwsAlbEnum3$outboundSchema: z.ZodEnum<typeof ProviderAwsAlbEnum3>;
+/** @internal */
+export type ProviderAwsAlb3$Outbound = {
+    ipAddressType?: string | null | undefined;
+    provider: string;
+    scheme: string;
+    subnetIds?: Array<string> | undefined;
+    targetType: string;
+};
+/** @internal */
+export declare const ProviderAwsAlb3$outboundSchema: z.ZodType<ProviderAwsAlb3$Outbound, ProviderAwsAlb3>;
+export declare function providerAwsAlb3ToJSON(providerAwsAlb3: ProviderAwsAlb3): string;
+/** @internal */
+export type ProviderUnion3$Outbound = ProviderAwsAlb3$Outbound | ProviderAzureApplicationGatewayForContainers3$Outbound | ProviderGkeGateway3$Outbound | any;
+/** @internal */
+export declare const ProviderUnion3$outboundSchema: z.ZodType<ProviderUnion3$Outbound, ProviderUnion3>;
+export declare function providerUnion3ToJSON(providerUnion3: ProviderUnion3): string;
+/** @internal */
+export type RouteIngress2$Outbound = {
+    annotations?: {
+        [k: string]: string;
+    } | undefined;
+    controller?: string | null | undefined;
+    ingressClassName: string;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    provider?: ProviderAwsAlb3$Outbound | ProviderAzureApplicationGatewayForContainers3$Outbound | ProviderGkeGateway3$Outbound | any | null | undefined;
+    routeApi: "ingress";
+};
+/** @internal */
+export declare const RouteIngress2$outboundSchema: z.ZodType<RouteIngress2$Outbound, RouteIngress2>;
+export declare function routeIngress2ToJSON(routeIngress2: RouteIngress2): string;
+/** @internal */
+export type RouteUnion2$Outbound = RouteIngress2$Outbound | RouteGateway2$Outbound;
+/** @internal */
+export declare const RouteUnion2$outboundSchema: z.ZodType<RouteUnion2$Outbound, RouteUnion2>;
+export declare function routeUnion2ToJSON(routeUnion2: RouteUnion2): string;
+/** @internal */
+export type ExposureCustom$Outbound = {
+    certificate: CertificateTLSSecretRef2$Outbound | CertificateManagedAcmImport2$Outbound | CertificateAwsAcmArn2$Outbound | CertificateManagedTLSSecret2$Outbound | CertificateNone2$Outbound;
+    domain: string;
+    mode: string;
+    route: RouteIngress2$Outbound | RouteGateway2$Outbound;
+};
+/** @internal */
+export declare const ExposureCustom$outboundSchema: z.ZodType<ExposureCustom$Outbound, ExposureCustom>;
+export declare function exposureCustomToJSON(exposureCustom: ExposureCustom): string;
+/** @internal */
+export type CertificateNone1$Outbound = {
+    mode: "none";
+};
+/** @internal */
+export declare const CertificateNone1$outboundSchema: z.ZodType<CertificateNone1$Outbound, CertificateNone1>;
+export declare function certificateNone1ToJSON(certificateNone1: CertificateNone1): string;
+/** @internal */
+export type CertificateManagedTLSSecret1$Outbound = {
+    mode: "managedTlsSecret";
+    secretNameTemplate: string;
+};
+/** @internal */
+export declare const CertificateManagedTLSSecret1$outboundSchema: z.ZodType<CertificateManagedTLSSecret1$Outbound, CertificateManagedTLSSecret1>;
+export declare function certificateManagedTLSSecret1ToJSON(certificateManagedTLSSecret1: CertificateManagedTLSSecret1): string;
+/** @internal */
+export type CertificateAwsAcmArn1$Outbound = {
+    certificateArn: string;
+    mode: "awsAcmArn";
+};
+/** @internal */
+export declare const CertificateAwsAcmArn1$outboundSchema: z.ZodType<CertificateAwsAcmArn1$Outbound, CertificateAwsAcmArn1>;
+export declare function certificateAwsAcmArn1ToJSON(certificateAwsAcmArn1: CertificateAwsAcmArn1): string;
+/** @internal */
+export type CertificateManagedAcmImport1$Outbound = {
+    mode: "managedAcmImport";
+    region?: string | null | undefined;
+    tags?: {
+        [k: string]: string;
+    } | undefined;
+};
+/** @internal */
+export declare const CertificateManagedAcmImport1$outboundSchema: z.ZodType<CertificateManagedAcmImport1$Outbound, CertificateManagedAcmImport1>;
+export declare function certificateManagedAcmImport1ToJSON(certificateManagedAcmImport1: CertificateManagedAcmImport1): string;
+/** @internal */
+export type CertificateTLSSecretRef1$Outbound = {
+    namespace?: string | null | undefined;
+    secretName: string;
+    mode: "tlsSecretRef";
+};
+/** @internal */
+export declare const CertificateTLSSecretRef1$outboundSchema: z.ZodType<CertificateTLSSecretRef1$Outbound, CertificateTLSSecretRef1>;
+export declare function certificateTLSSecretRef1ToJSON(certificateTLSSecretRef1: CertificateTLSSecretRef1): string;
+/** @internal */
+export type CertificateUnion1$Outbound = CertificateTLSSecretRef1$Outbound | CertificateManagedAcmImport1$Outbound | CertificateAwsAcmArn1$Outbound | CertificateManagedTLSSecret1$Outbound | CertificateNone1$Outbound;
+/** @internal */
+export declare const CertificateUnion1$outboundSchema: z.ZodType<CertificateUnion1$Outbound, CertificateUnion1>;
+export declare function certificateUnion1ToJSON(certificateUnion1: CertificateUnion1): string;
+/** @internal */
+export declare const ModeGenerated$outboundSchema: z.ZodEnum<typeof ModeGenerated>;
+/** @internal */
+export declare const ProviderAzureApplicationGatewayForContainersEnum2$outboundSchema: z.ZodEnum<typeof ProviderAzureApplicationGatewayForContainersEnum2>;
+/** @internal */
+export type ProviderAzureApplicationGatewayForContainers2$Outbound = {
+    albName?: string | null | undefined;
+    albNamespace?: string | null | undefined;
+    frontend: string;
+    provider: string;
+};
+/** @internal */
+export declare const ProviderAzureApplicationGatewayForContainers2$outboundSchema: z.ZodType<ProviderAzureApplicationGatewayForContainers2$Outbound, ProviderAzureApplicationGatewayForContainers2>;
+export declare function providerAzureApplicationGatewayForContainers2ToJSON(providerAzureApplicationGatewayForContainers2: ProviderAzureApplicationGatewayForContainers2): string;
+/** @internal */
+export declare const ProviderGkeGatewayEnum2$outboundSchema: z.ZodEnum<typeof ProviderGkeGatewayEnum2>;
+/** @internal */
+export type ProviderGkeGateway2$Outbound = {
+    provider: string;
+    staticAddressName?: string | null | undefined;
+};
+/** @internal */
+export declare const ProviderGkeGateway2$outboundSchema: z.ZodType<ProviderGkeGateway2$Outbound, ProviderGkeGateway2>;
+export declare function providerGkeGateway2ToJSON(providerGkeGateway2: ProviderGkeGateway2): string;
+/** @internal */
+export declare const ProviderAwsAlbEnum2$outboundSchema: z.ZodEnum<typeof ProviderAwsAlbEnum2>;
+/** @internal */
+export type ProviderAwsAlb2$Outbound = {
+    ipAddressType?: string | null | undefined;
+    provider: string;
+    scheme: string;
+    subnetIds?: Array<string> | undefined;
+    targetType: string;
+};
+/** @internal */
+export declare const ProviderAwsAlb2$outboundSchema: z.ZodType<ProviderAwsAlb2$Outbound, ProviderAwsAlb2>;
+export declare function providerAwsAlb2ToJSON(providerAwsAlb2: ProviderAwsAlb2): string;
+/** @internal */
+export type ProviderUnion2$Outbound = ProviderAwsAlb2$Outbound | ProviderAzureApplicationGatewayForContainers2$Outbound | ProviderGkeGateway2$Outbound | any;
+/** @internal */
+export declare const ProviderUnion2$outboundSchema: z.ZodType<ProviderUnion2$Outbound, ProviderUnion2>;
+export declare function providerUnion2ToJSON(providerUnion2: ProviderUnion2): string;
+/** @internal */
+export type RouteGateway1$Outbound = {
+    annotations?: {
+        [k: string]: string;
+    } | undefined;
+    controller?: string | null | undefined;
+    gatewayClassName: string;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    listenerPort: number;
+    provider?: ProviderAwsAlb2$Outbound | ProviderAzureApplicationGatewayForContainers2$Outbound | ProviderGkeGateway2$Outbound | any | null | undefined;
+    routeApi: "gateway";
+};
+/** @internal */
+export declare const RouteGateway1$outboundSchema: z.ZodType<RouteGateway1$Outbound, RouteGateway1>;
+export declare function routeGateway1ToJSON(routeGateway1: RouteGateway1): string;
+/** @internal */
+export declare const ProviderAzureApplicationGatewayForContainersEnum1$outboundSchema: z.ZodEnum<typeof ProviderAzureApplicationGatewayForContainersEnum1>;
+/** @internal */
+export type ProviderAzureApplicationGatewayForContainers1$Outbound = {
+    albName?: string | null | undefined;
+    albNamespace?: string | null | undefined;
+    frontend: string;
+    provider: string;
+};
+/** @internal */
+export declare const ProviderAzureApplicationGatewayForContainers1$outboundSchema: z.ZodType<ProviderAzureApplicationGatewayForContainers1$Outbound, ProviderAzureApplicationGatewayForContainers1>;
+export declare function providerAzureApplicationGatewayForContainers1ToJSON(providerAzureApplicationGatewayForContainers1: ProviderAzureApplicationGatewayForContainers1): string;
+/** @internal */
+export declare const ProviderGkeGatewayEnum1$outboundSchema: z.ZodEnum<typeof ProviderGkeGatewayEnum1>;
+/** @internal */
+export type ProviderGkeGateway1$Outbound = {
+    provider: string;
+    staticAddressName?: string | null | undefined;
+};
+/** @internal */
+export declare const ProviderGkeGateway1$outboundSchema: z.ZodType<ProviderGkeGateway1$Outbound, ProviderGkeGateway1>;
+export declare function providerGkeGateway1ToJSON(providerGkeGateway1: ProviderGkeGateway1): string;
+/** @internal */
+export declare const ProviderAwsAlbEnum1$outboundSchema: z.ZodEnum<typeof ProviderAwsAlbEnum1>;
+/** @internal */
+export type ProviderAwsAlb1$Outbound = {
+    ipAddressType?: string | null | undefined;
+    provider: string;
+    scheme: string;
+    subnetIds?: Array<string> | undefined;
+    targetType: string;
+};
+/** @internal */
+export declare const ProviderAwsAlb1$outboundSchema: z.ZodType<ProviderAwsAlb1$Outbound, ProviderAwsAlb1>;
+export declare function providerAwsAlb1ToJSON(providerAwsAlb1: ProviderAwsAlb1): string;
+/** @internal */
+export type ProviderUnion1$Outbound = ProviderAwsAlb1$Outbound | ProviderAzureApplicationGatewayForContainers1$Outbound | ProviderGkeGateway1$Outbound | any;
+/** @internal */
+export declare const ProviderUnion1$outboundSchema: z.ZodType<ProviderUnion1$Outbound, ProviderUnion1>;
+export declare function providerUnion1ToJSON(providerUnion1: ProviderUnion1): string;
+/** @internal */
+export type RouteIngress1$Outbound = {
+    annotations?: {
+        [k: string]: string;
+    } | undefined;
+    controller?: string | null | undefined;
+    ingressClassName: string;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    provider?: ProviderAwsAlb1$Outbound | ProviderAzureApplicationGatewayForContainers1$Outbound | ProviderGkeGateway1$Outbound | any | null | undefined;
+    routeApi: "ingress";
+};
+/** @internal */
+export declare const RouteIngress1$outboundSchema: z.ZodType<RouteIngress1$Outbound, RouteIngress1>;
+export declare function routeIngress1ToJSON(routeIngress1: RouteIngress1): string;
+/** @internal */
+export type RouteUnion1$Outbound = RouteIngress1$Outbound | RouteGateway1$Outbound;
+/** @internal */
+export declare const RouteUnion1$outboundSchema: z.ZodType<RouteUnion1$Outbound, RouteUnion1>;
+export declare function routeUnion1ToJSON(routeUnion1: RouteUnion1): string;
+/** @internal */
+export type ExposureGenerated$Outbound = {
+    certificate: CertificateTLSSecretRef1$Outbound | CertificateManagedAcmImport1$Outbound | CertificateAwsAcmArn1$Outbound | CertificateManagedTLSSecret1$Outbound | CertificateNone1$Outbound;
+    mode: string;
+    route: RouteIngress1$Outbound | RouteGateway1$Outbound;
+};
+/** @internal */
+export declare const ExposureGenerated$outboundSchema: z.ZodType<ExposureGenerated$Outbound, ExposureGenerated>;
+export declare function exposureGeneratedToJSON(exposureGenerated: ExposureGenerated): string;
+/** @internal */
+export declare const ModeDisabled$outboundSchema: z.ZodEnum<typeof ModeDisabled>;
+/** @internal */
+export type ExposureDisabled$Outbound = {
+    mode: string;
+};
+/** @internal */
+export declare const ExposureDisabled$outboundSchema: z.ZodType<ExposureDisabled$Outbound, ExposureDisabled>;
+export declare function exposureDisabledToJSON(exposureDisabled: ExposureDisabled): string;
+/** @internal */
+export type Exposure$Outbound = ExposureCustom$Outbound | ExposureGenerated$Outbound | ExposureDisabled$Outbound | any;
+/** @internal */
+export declare const Exposure$outboundSchema: z.ZodType<Exposure$Outbound, Exposure>;
+export declare function exposureToJSON(exposure: Exposure): string;
+/** @internal */
+export type PrepareDeploymentStackKubernetes$Outbound = {
+    cluster?: Cluster$Outbound | any | null | undefined;
+    exposure?: ExposureCustom$Outbound | ExposureGenerated$Outbound | ExposureDisabled$Outbound | any | null | undefined;
+};
+/** @internal */
+export declare const PrepareDeploymentStackKubernetes$outboundSchema: z.ZodType<PrepareDeploymentStackKubernetes$Outbound, PrepareDeploymentStackKubernetes>;
+export declare function prepareDeploymentStackKubernetesToJSON(prepareDeploymentStackKubernetes: PrepareDeploymentStackKubernetes): string;
+/** @internal */
+export type Kubernetes$Outbound = PrepareDeploymentStackKubernetes$Outbound | any;
+/** @internal */
+export declare const Kubernetes$outboundSchema: z.ZodType<Kubernetes$Outbound, Kubernetes>;
+export declare function kubernetesToJSON(kubernetes: Kubernetes): string;
+/** @internal */
+export declare const TypeByoVnetAzure$outboundSchema: z.ZodEnum<typeof TypeByoVnetAzure>;
+/** @internal */
+export type NetworkByoVnetAzure$Outbound = {
+    private_subnet_name: string;
+    public_subnet_name: string;
+    type: string;
+    vnet_resource_id: string;
+};
+/** @internal */
+export declare const NetworkByoVnetAzure$outboundSchema: z.ZodType<NetworkByoVnetAzure$Outbound, NetworkByoVnetAzure>;
+export declare function networkByoVnetAzureToJSON(networkByoVnetAzure: NetworkByoVnetAzure): string;
+/** @internal */
+export declare const TypeByoVpcGcp$outboundSchema: z.ZodEnum<typeof TypeByoVpcGcp>;
+/** @internal */
+export type NetworkByoVpcGcp$Outbound = {
+    network_name: string;
+    region: string;
+    subnet_name: string;
+    type: string;
+};
+/** @internal */
+export declare const NetworkByoVpcGcp$outboundSchema: z.ZodType<NetworkByoVpcGcp$Outbound, NetworkByoVpcGcp>;
+export declare function networkByoVpcGcpToJSON(networkByoVpcGcp: NetworkByoVpcGcp): string;
+/** @internal */
+export declare const TypeByoVpcAws$outboundSchema: z.ZodEnum<typeof TypeByoVpcAws>;
+/** @internal */
+export type NetworkByoVpcAws$Outbound = {
+    private_subnet_ids: Array<string>;
+    public_subnet_ids: Array<string>;
+    security_group_ids?: Array<string> | undefined;
+    type: string;
+    vpc_id: string;
+};
+/** @internal */
+export declare const NetworkByoVpcAws$outboundSchema: z.ZodType<NetworkByoVpcAws$Outbound, NetworkByoVpcAws>;
+export declare function networkByoVpcAwsToJSON(networkByoVpcAws: NetworkByoVpcAws): string;
+/** @internal */
+export declare const TypeCreate$outboundSchema: z.ZodEnum<typeof TypeCreate>;
+/** @internal */
+export type NetworkCreate$Outbound = {
+    availability_zones?: number | undefined;
+    cidr?: string | null | undefined;
+    type: string;
+};
+/** @internal */
+export declare const NetworkCreate$outboundSchema: z.ZodType<NetworkCreate$Outbound, NetworkCreate>;
+export declare function networkCreateToJSON(networkCreate: NetworkCreate): string;
+/** @internal */
+export declare const TypeUseDefault$outboundSchema: z.ZodEnum<typeof TypeUseDefault>;
+/** @internal */
+export type NetworkUseDefault$Outbound = {
+    type: string;
+};
+/** @internal */
+export declare const NetworkUseDefault$outboundSchema: z.ZodType<NetworkUseDefault$Outbound, NetworkUseDefault>;
+export declare function networkUseDefaultToJSON(networkUseDefault: NetworkUseDefault): string;
+/** @internal */
+export type Network$Outbound = NetworkByoVpcAws$Outbound | NetworkByoVpcGcp$Outbound | NetworkByoVnetAzure$Outbound | NetworkUseDefault$Outbound | NetworkCreate$Outbound | any;
+/** @internal */
+export declare const Network$outboundSchema: z.ZodType<Network$Outbound, Network>;
+export declare function networkToJSON(network: Network): string;
+/** @internal */
+export declare const Telemetry$outboundSchema: z.ZodEnum<typeof Telemetry>;
+/** @internal */
+export declare const Updates$outboundSchema: z.ZodEnum<typeof Updates>;
+/** @internal */
+export type StackSettings$Outbound = {
+    deploymentModel?: string | undefined;
+    domains?: Domains$Outbound | any | null | undefined;
+    externalBindings?: ExternalBindings$Outbound | null | undefined;
+    heartbeats?: string | undefined;
+    kubernetes?: PrepareDeploymentStackKubernetes$Outbound | any | null | undefined;
+    network?: NetworkByoVpcAws$Outbound | NetworkByoVpcGcp$Outbound | NetworkByoVnetAzure$Outbound | NetworkUseDefault$Outbound | NetworkCreate$Outbound | any | null | undefined;
+    telemetry?: string | undefined;
+    updates?: string | undefined;
+};
+/** @internal */
+export declare const StackSettings$outboundSchema: z.ZodType<StackSettings$Outbound, StackSettings>;
+export declare function stackSettingsToJSON(stackSettings: StackSettings): string;
+/** @internal */
+export type PrepareDeploymentStackRequestBody$Outbound = {
+    platform: string;
+    setupMethod: string;
+    region?: string | undefined;
+    stackSettings: StackSettings$Outbound;
+};
+/** @internal */
+export declare const PrepareDeploymentStackRequestBody$outboundSchema: z.ZodType<PrepareDeploymentStackRequestBody$Outbound, PrepareDeploymentStackRequestBody>;
+export declare function prepareDeploymentStackRequestBodyToJSON(prepareDeploymentStackRequestBody: PrepareDeploymentStackRequestBody): string;
+/** @internal */
+export type PrepareDeploymentStackRequest$Outbound = {
+    workspace?: string | undefined;
+    RequestBody?: PrepareDeploymentStackRequestBody$Outbound | undefined;
+};
+/** @internal */
+export declare const PrepareDeploymentStackRequest$outboundSchema: z.ZodType<PrepareDeploymentStackRequest$Outbound, PrepareDeploymentStackRequest>;
+export declare function prepareDeploymentStackRequestToJSON(prepareDeploymentStackRequest: PrepareDeploymentStackRequest): string;
+//# sourceMappingURL=preparedeploymentstack.d.ts.map