# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'EnvironmentConfig',
    'EnvironmentConfigDatabaseConfig',
    'EnvironmentConfigEncryptionConfig',
    'EnvironmentConfigMaintenanceWindow',
    'EnvironmentConfigMasterAuthorizedNetworksConfig',
    'EnvironmentConfigMasterAuthorizedNetworksConfigCidrBlock',
    'EnvironmentConfigNodeConfig',
    'EnvironmentConfigNodeConfigIpAllocationPolicy',
    'EnvironmentConfigPrivateEnvironmentConfig',
    'EnvironmentConfigRecoveryConfig',
    'EnvironmentConfigRecoveryConfigScheduledSnapshotsConfig',
    'EnvironmentConfigSoftwareConfig',
    'EnvironmentConfigSoftwareConfigCloudDataLineageIntegration',
    'EnvironmentConfigWebServerConfig',
    'EnvironmentConfigWebServerNetworkAccessControl',
    'EnvironmentConfigWebServerNetworkAccessControlAllowedIpRange',
    'EnvironmentConfigWorkloadsConfig',
    'EnvironmentConfigWorkloadsConfigScheduler',
    'EnvironmentConfigWorkloadsConfigTriggerer',
    'EnvironmentConfigWorkloadsConfigWebServer',
    'EnvironmentConfigWorkloadsConfigWorker',
    'GetEnvironmentConfigResult',
    'GetEnvironmentConfigDatabaseConfigResult',
    'GetEnvironmentConfigEncryptionConfigResult',
    'GetEnvironmentConfigMaintenanceWindowResult',
    'GetEnvironmentConfigMasterAuthorizedNetworksConfigResult',
    'GetEnvironmentConfigMasterAuthorizedNetworksConfigCidrBlockResult',
    'GetEnvironmentConfigNodeConfigResult',
    'GetEnvironmentConfigNodeConfigIpAllocationPolicyResult',
    'GetEnvironmentConfigPrivateEnvironmentConfigResult',
    'GetEnvironmentConfigRecoveryConfigResult',
    'GetEnvironmentConfigRecoveryConfigScheduledSnapshotsConfigResult',
    'GetEnvironmentConfigSoftwareConfigResult',
    'GetEnvironmentConfigSoftwareConfigCloudDataLineageIntegrationResult',
    'GetEnvironmentConfigWebServerConfigResult',
    'GetEnvironmentConfigWebServerNetworkAccessControlResult',
    'GetEnvironmentConfigWebServerNetworkAccessControlAllowedIpRangeResult',
    'GetEnvironmentConfigWorkloadsConfigResult',
    'GetEnvironmentConfigWorkloadsConfigSchedulerResult',
    'GetEnvironmentConfigWorkloadsConfigTriggererResult',
    'GetEnvironmentConfigWorkloadsConfigWebServerResult',
    'GetEnvironmentConfigWorkloadsConfigWorkerResult',
    'GetImageVersionsImageVersionResult',
]

@pulumi.output_type
class EnvironmentConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "airflowUri":
            suggest = "airflow_uri"
        elif key == "dagGcsPrefix":
            suggest = "dag_gcs_prefix"
        elif key == "databaseConfig":
            suggest = "database_config"
        elif key == "encryptionConfig":
            suggest = "encryption_config"
        elif key == "environmentSize":
            suggest = "environment_size"
        elif key == "gkeCluster":
            suggest = "gke_cluster"
        elif key == "maintenanceWindow":
            suggest = "maintenance_window"
        elif key == "masterAuthorizedNetworksConfig":
            suggest = "master_authorized_networks_config"
        elif key == "nodeConfig":
            suggest = "node_config"
        elif key == "nodeCount":
            suggest = "node_count"
        elif key == "privateEnvironmentConfig":
            suggest = "private_environment_config"
        elif key == "recoveryConfig":
            suggest = "recovery_config"
        elif key == "softwareConfig":
            suggest = "software_config"
        elif key == "webServerConfig":
            suggest = "web_server_config"
        elif key == "webServerNetworkAccessControl":
            suggest = "web_server_network_access_control"
        elif key == "workloadsConfig":
            suggest = "workloads_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 airflow_uri: Optional[str] = None,
                 dag_gcs_prefix: Optional[str] = None,
                 database_config: Optional['outputs.EnvironmentConfigDatabaseConfig'] = None,
                 encryption_config: Optional['outputs.EnvironmentConfigEncryptionConfig'] = None,
                 environment_size: Optional[str] = None,
                 gke_cluster: Optional[str] = None,
                 maintenance_window: Optional['outputs.EnvironmentConfigMaintenanceWindow'] = None,
                 master_authorized_networks_config: Optional['outputs.EnvironmentConfigMasterAuthorizedNetworksConfig'] = None,
                 node_config: Optional['outputs.EnvironmentConfigNodeConfig'] = None,
                 node_count: Optional[int] = None,
                 private_environment_config: Optional['outputs.EnvironmentConfigPrivateEnvironmentConfig'] = None,
                 recovery_config: Optional['outputs.EnvironmentConfigRecoveryConfig'] = None,
                 software_config: Optional['outputs.EnvironmentConfigSoftwareConfig'] = None,
                 web_server_config: Optional['outputs.EnvironmentConfigWebServerConfig'] = None,
                 web_server_network_access_control: Optional['outputs.EnvironmentConfigWebServerNetworkAccessControl'] = None,
                 workloads_config: Optional['outputs.EnvironmentConfigWorkloadsConfig'] = None):
        if airflow_uri is not None:
            pulumi.set(__self__, "airflow_uri", airflow_uri)
        if dag_gcs_prefix is not None:
            pulumi.set(__self__, "dag_gcs_prefix", dag_gcs_prefix)
        if database_config is not None:
            pulumi.set(__self__, "database_config", database_config)
        if encryption_config is not None:
            pulumi.set(__self__, "encryption_config", encryption_config)
        if environment_size is not None:
            pulumi.set(__self__, "environment_size", environment_size)
        if gke_cluster is not None:
            pulumi.set(__self__, "gke_cluster", gke_cluster)
        if maintenance_window is not None:
            pulumi.set(__self__, "maintenance_window", maintenance_window)
        if master_authorized_networks_config is not None:
            pulumi.set(__self__, "master_authorized_networks_config", master_authorized_networks_config)
        if node_config is not None:
            pulumi.set(__self__, "node_config", node_config)
        if node_count is not None:
            pulumi.set(__self__, "node_count", node_count)
        if private_environment_config is not None:
            pulumi.set(__self__, "private_environment_config", private_environment_config)
        if recovery_config is not None:
            pulumi.set(__self__, "recovery_config", recovery_config)
        if software_config is not None:
            pulumi.set(__self__, "software_config", software_config)
        if web_server_config is not None:
            pulumi.set(__self__, "web_server_config", web_server_config)
        if web_server_network_access_control is not None:
            pulumi.set(__self__, "web_server_network_access_control", web_server_network_access_control)
        if workloads_config is not None:
            pulumi.set(__self__, "workloads_config", workloads_config)

    @property
    @pulumi.getter(name="airflowUri")
    def airflow_uri(self) -> Optional[str]:
        return pulumi.get(self, "airflow_uri")

    @property
    @pulumi.getter(name="dagGcsPrefix")
    def dag_gcs_prefix(self) -> Optional[str]:
        return pulumi.get(self, "dag_gcs_prefix")

    @property
    @pulumi.getter(name="databaseConfig")
    def database_config(self) -> Optional['outputs.EnvironmentConfigDatabaseConfig']:
        return pulumi.get(self, "database_config")

    @property
    @pulumi.getter(name="encryptionConfig")
    def encryption_config(self) -> Optional['outputs.EnvironmentConfigEncryptionConfig']:
        return pulumi.get(self, "encryption_config")

    @property
    @pulumi.getter(name="environmentSize")
    def environment_size(self) -> Optional[str]:
        return pulumi.get(self, "environment_size")

    @property
    @pulumi.getter(name="gkeCluster")
    def gke_cluster(self) -> Optional[str]:
        return pulumi.get(self, "gke_cluster")

    @property
    @pulumi.getter(name="maintenanceWindow")
    def maintenance_window(self) -> Optional['outputs.EnvironmentConfigMaintenanceWindow']:
        return pulumi.get(self, "maintenance_window")

    @property
    @pulumi.getter(name="masterAuthorizedNetworksConfig")
    def master_authorized_networks_config(self) -> Optional['outputs.EnvironmentConfigMasterAuthorizedNetworksConfig']:
        return pulumi.get(self, "master_authorized_networks_config")

    @property
    @pulumi.getter(name="nodeConfig")
    def node_config(self) -> Optional['outputs.EnvironmentConfigNodeConfig']:
        return pulumi.get(self, "node_config")

    @property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> Optional[int]:
        return pulumi.get(self, "node_count")

    @property
    @pulumi.getter(name="privateEnvironmentConfig")
    def private_environment_config(self) -> Optional['outputs.EnvironmentConfigPrivateEnvironmentConfig']:
        return pulumi.get(self, "private_environment_config")

    @property
    @pulumi.getter(name="recoveryConfig")
    def recovery_config(self) -> Optional['outputs.EnvironmentConfigRecoveryConfig']:
        return pulumi.get(self, "recovery_config")

    @property
    @pulumi.getter(name="softwareConfig")
    def software_config(self) -> Optional['outputs.EnvironmentConfigSoftwareConfig']:
        return pulumi.get(self, "software_config")

    @property
    @pulumi.getter(name="webServerConfig")
    def web_server_config(self) -> Optional['outputs.EnvironmentConfigWebServerConfig']:
        return pulumi.get(self, "web_server_config")

    @property
    @pulumi.getter(name="webServerNetworkAccessControl")
    def web_server_network_access_control(self) -> Optional['outputs.EnvironmentConfigWebServerNetworkAccessControl']:
        return pulumi.get(self, "web_server_network_access_control")

    @property
    @pulumi.getter(name="workloadsConfig")
    def workloads_config(self) -> Optional['outputs.EnvironmentConfigWorkloadsConfig']:
        return pulumi.get(self, "workloads_config")


@pulumi.output_type
class EnvironmentConfigDatabaseConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "machineType":
            suggest = "machine_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigDatabaseConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigDatabaseConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigDatabaseConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 machine_type: str):
        pulumi.set(__self__, "machine_type", machine_type)

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> str:
        return pulumi.get(self, "machine_type")


@pulumi.output_type
class EnvironmentConfigEncryptionConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeyName":
            suggest = "kms_key_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigEncryptionConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigEncryptionConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigEncryptionConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_name: str):
        pulumi.set(__self__, "kms_key_name", kms_key_name)

    @property
    @pulumi.getter(name="kmsKeyName")
    def kms_key_name(self) -> str:
        return pulumi.get(self, "kms_key_name")


@pulumi.output_type
class EnvironmentConfigMaintenanceWindow(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endTime":
            suggest = "end_time"
        elif key == "startTime":
            suggest = "start_time"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigMaintenanceWindow. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigMaintenanceWindow.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigMaintenanceWindow.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 end_time: str,
                 recurrence: str,
                 start_time: str):
        pulumi.set(__self__, "end_time", end_time)
        pulumi.set(__self__, "recurrence", recurrence)
        pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> str:
        return pulumi.get(self, "end_time")

    @property
    @pulumi.getter
    def recurrence(self) -> str:
        return pulumi.get(self, "recurrence")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> str:
        return pulumi.get(self, "start_time")


@pulumi.output_type
class EnvironmentConfigMasterAuthorizedNetworksConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cidrBlocks":
            suggest = "cidr_blocks"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigMasterAuthorizedNetworksConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigMasterAuthorizedNetworksConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigMasterAuthorizedNetworksConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: bool,
                 cidr_blocks: Optional[Sequence['outputs.EnvironmentConfigMasterAuthorizedNetworksConfigCidrBlock']] = None):
        pulumi.set(__self__, "enabled", enabled)
        if cidr_blocks is not None:
            pulumi.set(__self__, "cidr_blocks", cidr_blocks)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="cidrBlocks")
    def cidr_blocks(self) -> Optional[Sequence['outputs.EnvironmentConfigMasterAuthorizedNetworksConfigCidrBlock']]:
        return pulumi.get(self, "cidr_blocks")


@pulumi.output_type
class EnvironmentConfigMasterAuthorizedNetworksConfigCidrBlock(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cidrBlock":
            suggest = "cidr_block"
        elif key == "displayName":
            suggest = "display_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigMasterAuthorizedNetworksConfigCidrBlock. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigMasterAuthorizedNetworksConfigCidrBlock.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigMasterAuthorizedNetworksConfigCidrBlock.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cidr_block: str,
                 display_name: Optional[str] = None):
        pulumi.set(__self__, "cidr_block", cidr_block)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)

    @property
    @pulumi.getter(name="cidrBlock")
    def cidr_block(self) -> str:
        return pulumi.get(self, "cidr_block")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[str]:
        return pulumi.get(self, "display_name")


@pulumi.output_type
class EnvironmentConfigNodeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "diskSizeGb":
            suggest = "disk_size_gb"
        elif key == "enableIpMasqAgent":
            suggest = "enable_ip_masq_agent"
        elif key == "ipAllocationPolicy":
            suggest = "ip_allocation_policy"
        elif key == "machineType":
            suggest = "machine_type"
        elif key == "maxPodsPerNode":
            suggest = "max_pods_per_node"
        elif key == "oauthScopes":
            suggest = "oauth_scopes"
        elif key == "serviceAccount":
            suggest = "service_account"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigNodeConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigNodeConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigNodeConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disk_size_gb: Optional[int] = None,
                 enable_ip_masq_agent: Optional[bool] = None,
                 ip_allocation_policy: Optional['outputs.EnvironmentConfigNodeConfigIpAllocationPolicy'] = None,
                 machine_type: Optional[str] = None,
                 max_pods_per_node: Optional[int] = None,
                 network: Optional[str] = None,
                 oauth_scopes: Optional[Sequence[str]] = None,
                 service_account: Optional[str] = None,
                 subnetwork: Optional[str] = None,
                 tags: Optional[Sequence[str]] = None,
                 zone: Optional[str] = None):
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if enable_ip_masq_agent is not None:
            pulumi.set(__self__, "enable_ip_masq_agent", enable_ip_masq_agent)
        if ip_allocation_policy is not None:
            pulumi.set(__self__, "ip_allocation_policy", ip_allocation_policy)
        if machine_type is not None:
            pulumi.set(__self__, "machine_type", machine_type)
        if max_pods_per_node is not None:
            pulumi.set(__self__, "max_pods_per_node", max_pods_per_node)
        if network is not None:
            pulumi.set(__self__, "network", network)
        if oauth_scopes is not None:
            pulumi.set(__self__, "oauth_scopes", oauth_scopes)
        if service_account is not None:
            pulumi.set(__self__, "service_account", service_account)
        if subnetwork is not None:
            pulumi.set(__self__, "subnetwork", subnetwork)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[int]:
        return pulumi.get(self, "disk_size_gb")

    @property
    @pulumi.getter(name="enableIpMasqAgent")
    def enable_ip_masq_agent(self) -> Optional[bool]:
        return pulumi.get(self, "enable_ip_masq_agent")

    @property
    @pulumi.getter(name="ipAllocationPolicy")
    def ip_allocation_policy(self) -> Optional['outputs.EnvironmentConfigNodeConfigIpAllocationPolicy']:
        return pulumi.get(self, "ip_allocation_policy")

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> Optional[str]:
        return pulumi.get(self, "machine_type")

    @property
    @pulumi.getter(name="maxPodsPerNode")
    def max_pods_per_node(self) -> Optional[int]:
        return pulumi.get(self, "max_pods_per_node")

    @property
    @pulumi.getter
    def network(self) -> Optional[str]:
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "oauth_scopes")

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> Optional[str]:
        return pulumi.get(self, "service_account")

    @property
    @pulumi.getter
    def subnetwork(self) -> Optional[str]:
        return pulumi.get(self, "subnetwork")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def zone(self) -> Optional[str]:
        return pulumi.get(self, "zone")


@pulumi.output_type
class EnvironmentConfigNodeConfigIpAllocationPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterIpv4CidrBlock":
            suggest = "cluster_ipv4_cidr_block"
        elif key == "clusterSecondaryRangeName":
            suggest = "cluster_secondary_range_name"
        elif key == "servicesIpv4CidrBlock":
            suggest = "services_ipv4_cidr_block"
        elif key == "servicesSecondaryRangeName":
            suggest = "services_secondary_range_name"
        elif key == "useIpAliases":
            suggest = "use_ip_aliases"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigNodeConfigIpAllocationPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigNodeConfigIpAllocationPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigNodeConfigIpAllocationPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cluster_ipv4_cidr_block: Optional[str] = None,
                 cluster_secondary_range_name: Optional[str] = None,
                 services_ipv4_cidr_block: Optional[str] = None,
                 services_secondary_range_name: Optional[str] = None,
                 use_ip_aliases: Optional[bool] = None):
        if cluster_ipv4_cidr_block is not None:
            pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
        if cluster_secondary_range_name is not None:
            pulumi.set(__self__, "cluster_secondary_range_name", cluster_secondary_range_name)
        if services_ipv4_cidr_block is not None:
            pulumi.set(__self__, "services_ipv4_cidr_block", services_ipv4_cidr_block)
        if services_secondary_range_name is not None:
            pulumi.set(__self__, "services_secondary_range_name", services_secondary_range_name)
        if use_ip_aliases is not None:
            pulumi.set(__self__, "use_ip_aliases", use_ip_aliases)

    @property
    @pulumi.getter(name="clusterIpv4CidrBlock")
    def cluster_ipv4_cidr_block(self) -> Optional[str]:
        return pulumi.get(self, "cluster_ipv4_cidr_block")

    @property
    @pulumi.getter(name="clusterSecondaryRangeName")
    def cluster_secondary_range_name(self) -> Optional[str]:
        return pulumi.get(self, "cluster_secondary_range_name")

    @property
    @pulumi.getter(name="servicesIpv4CidrBlock")
    def services_ipv4_cidr_block(self) -> Optional[str]:
        return pulumi.get(self, "services_ipv4_cidr_block")

    @property
    @pulumi.getter(name="servicesSecondaryRangeName")
    def services_secondary_range_name(self) -> Optional[str]:
        return pulumi.get(self, "services_secondary_range_name")

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> Optional[bool]:
        return pulumi.get(self, "use_ip_aliases")


@pulumi.output_type
class EnvironmentConfigPrivateEnvironmentConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudComposerConnectionSubnetwork":
            suggest = "cloud_composer_connection_subnetwork"
        elif key == "cloudComposerNetworkIpv4CidrBlock":
            suggest = "cloud_composer_network_ipv4_cidr_block"
        elif key == "cloudSqlIpv4CidrBlock":
            suggest = "cloud_sql_ipv4_cidr_block"
        elif key == "enablePrivateEndpoint":
            suggest = "enable_private_endpoint"
        elif key == "enablePrivatelyUsedPublicIps":
            suggest = "enable_privately_used_public_ips"
        elif key == "masterIpv4CidrBlock":
            suggest = "master_ipv4_cidr_block"
        elif key == "webServerIpv4CidrBlock":
            suggest = "web_server_ipv4_cidr_block"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigPrivateEnvironmentConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigPrivateEnvironmentConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigPrivateEnvironmentConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cloud_composer_connection_subnetwork: Optional[str] = None,
                 cloud_composer_network_ipv4_cidr_block: Optional[str] = None,
                 cloud_sql_ipv4_cidr_block: Optional[str] = None,
                 enable_private_endpoint: Optional[bool] = None,
                 enable_privately_used_public_ips: Optional[bool] = None,
                 master_ipv4_cidr_block: Optional[str] = None,
                 web_server_ipv4_cidr_block: Optional[str] = None):
        if cloud_composer_connection_subnetwork is not None:
            pulumi.set(__self__, "cloud_composer_connection_subnetwork", cloud_composer_connection_subnetwork)
        if cloud_composer_network_ipv4_cidr_block is not None:
            pulumi.set(__self__, "cloud_composer_network_ipv4_cidr_block", cloud_composer_network_ipv4_cidr_block)
        if cloud_sql_ipv4_cidr_block is not None:
            pulumi.set(__self__, "cloud_sql_ipv4_cidr_block", cloud_sql_ipv4_cidr_block)
        if enable_private_endpoint is not None:
            pulumi.set(__self__, "enable_private_endpoint", enable_private_endpoint)
        if enable_privately_used_public_ips is not None:
            pulumi.set(__self__, "enable_privately_used_public_ips", enable_privately_used_public_ips)
        if master_ipv4_cidr_block is not None:
            pulumi.set(__self__, "master_ipv4_cidr_block", master_ipv4_cidr_block)
        if web_server_ipv4_cidr_block is not None:
            pulumi.set(__self__, "web_server_ipv4_cidr_block", web_server_ipv4_cidr_block)

    @property
    @pulumi.getter(name="cloudComposerConnectionSubnetwork")
    def cloud_composer_connection_subnetwork(self) -> Optional[str]:
        return pulumi.get(self, "cloud_composer_connection_subnetwork")

    @property
    @pulumi.getter(name="cloudComposerNetworkIpv4CidrBlock")
    def cloud_composer_network_ipv4_cidr_block(self) -> Optional[str]:
        return pulumi.get(self, "cloud_composer_network_ipv4_cidr_block")

    @property
    @pulumi.getter(name="cloudSqlIpv4CidrBlock")
    def cloud_sql_ipv4_cidr_block(self) -> Optional[str]:
        return pulumi.get(self, "cloud_sql_ipv4_cidr_block")

    @property
    @pulumi.getter(name="enablePrivateEndpoint")
    def enable_private_endpoint(self) -> Optional[bool]:
        return pulumi.get(self, "enable_private_endpoint")

    @property
    @pulumi.getter(name="enablePrivatelyUsedPublicIps")
    def enable_privately_used_public_ips(self) -> Optional[bool]:
        return pulumi.get(self, "enable_privately_used_public_ips")

    @property
    @pulumi.getter(name="masterIpv4CidrBlock")
    def master_ipv4_cidr_block(self) -> Optional[str]:
        return pulumi.get(self, "master_ipv4_cidr_block")

    @property
    @pulumi.getter(name="webServerIpv4CidrBlock")
    def web_server_ipv4_cidr_block(self) -> Optional[str]:
        return pulumi.get(self, "web_server_ipv4_cidr_block")


@pulumi.output_type
class EnvironmentConfigRecoveryConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scheduledSnapshotsConfig":
            suggest = "scheduled_snapshots_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigRecoveryConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigRecoveryConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigRecoveryConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 scheduled_snapshots_config: Optional['outputs.EnvironmentConfigRecoveryConfigScheduledSnapshotsConfig'] = None):
        if scheduled_snapshots_config is not None:
            pulumi.set(__self__, "scheduled_snapshots_config", scheduled_snapshots_config)

    @property
    @pulumi.getter(name="scheduledSnapshotsConfig")
    def scheduled_snapshots_config(self) -> Optional['outputs.EnvironmentConfigRecoveryConfigScheduledSnapshotsConfig']:
        return pulumi.get(self, "scheduled_snapshots_config")


@pulumi.output_type
class EnvironmentConfigRecoveryConfigScheduledSnapshotsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "snapshotCreationSchedule":
            suggest = "snapshot_creation_schedule"
        elif key == "snapshotLocation":
            suggest = "snapshot_location"
        elif key == "timeZone":
            suggest = "time_zone"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigRecoveryConfigScheduledSnapshotsConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigRecoveryConfigScheduledSnapshotsConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigRecoveryConfigScheduledSnapshotsConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: bool,
                 snapshot_creation_schedule: Optional[str] = None,
                 snapshot_location: Optional[str] = None,
                 time_zone: Optional[str] = None):
        pulumi.set(__self__, "enabled", enabled)
        if snapshot_creation_schedule is not None:
            pulumi.set(__self__, "snapshot_creation_schedule", snapshot_creation_schedule)
        if snapshot_location is not None:
            pulumi.set(__self__, "snapshot_location", snapshot_location)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="snapshotCreationSchedule")
    def snapshot_creation_schedule(self) -> Optional[str]:
        return pulumi.get(self, "snapshot_creation_schedule")

    @property
    @pulumi.getter(name="snapshotLocation")
    def snapshot_location(self) -> Optional[str]:
        return pulumi.get(self, "snapshot_location")

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[str]:
        return pulumi.get(self, "time_zone")


@pulumi.output_type
class EnvironmentConfigSoftwareConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "airflowConfigOverrides":
            suggest = "airflow_config_overrides"
        elif key == "cloudDataLineageIntegration":
            suggest = "cloud_data_lineage_integration"
        elif key == "envVariables":
            suggest = "env_variables"
        elif key == "imageVersion":
            suggest = "image_version"
        elif key == "pypiPackages":
            suggest = "pypi_packages"
        elif key == "pythonVersion":
            suggest = "python_version"
        elif key == "schedulerCount":
            suggest = "scheduler_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigSoftwareConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigSoftwareConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigSoftwareConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 airflow_config_overrides: Optional[Mapping[str, str]] = None,
                 cloud_data_lineage_integration: Optional['outputs.EnvironmentConfigSoftwareConfigCloudDataLineageIntegration'] = None,
                 env_variables: Optional[Mapping[str, str]] = None,
                 image_version: Optional[str] = None,
                 pypi_packages: Optional[Mapping[str, str]] = None,
                 python_version: Optional[str] = None,
                 scheduler_count: Optional[int] = None):
        if airflow_config_overrides is not None:
            pulumi.set(__self__, "airflow_config_overrides", airflow_config_overrides)
        if cloud_data_lineage_integration is not None:
            pulumi.set(__self__, "cloud_data_lineage_integration", cloud_data_lineage_integration)
        if env_variables is not None:
            pulumi.set(__self__, "env_variables", env_variables)
        if image_version is not None:
            pulumi.set(__self__, "image_version", image_version)
        if pypi_packages is not None:
            pulumi.set(__self__, "pypi_packages", pypi_packages)
        if python_version is not None:
            pulumi.set(__self__, "python_version", python_version)
        if scheduler_count is not None:
            pulumi.set(__self__, "scheduler_count", scheduler_count)

    @property
    @pulumi.getter(name="airflowConfigOverrides")
    def airflow_config_overrides(self) -> Optional[Mapping[str, str]]:
        return pulumi.get(self, "airflow_config_overrides")

    @property
    @pulumi.getter(name="cloudDataLineageIntegration")
    def cloud_data_lineage_integration(self) -> Optional['outputs.EnvironmentConfigSoftwareConfigCloudDataLineageIntegration']:
        return pulumi.get(self, "cloud_data_lineage_integration")

    @property
    @pulumi.getter(name="envVariables")
    def env_variables(self) -> Optional[Mapping[str, str]]:
        return pulumi.get(self, "env_variables")

    @property
    @pulumi.getter(name="imageVersion")
    def image_version(self) -> Optional[str]:
        return pulumi.get(self, "image_version")

    @property
    @pulumi.getter(name="pypiPackages")
    def pypi_packages(self) -> Optional[Mapping[str, str]]:
        return pulumi.get(self, "pypi_packages")

    @property
    @pulumi.getter(name="pythonVersion")
    def python_version(self) -> Optional[str]:
        return pulumi.get(self, "python_version")

    @property
    @pulumi.getter(name="schedulerCount")
    def scheduler_count(self) -> Optional[int]:
        return pulumi.get(self, "scheduler_count")


@pulumi.output_type
class EnvironmentConfigSoftwareConfigCloudDataLineageIntegration(dict):
    def __init__(__self__, *,
                 enabled: bool):
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class EnvironmentConfigWebServerConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "machineType":
            suggest = "machine_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigWebServerConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigWebServerConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigWebServerConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 machine_type: str):
        pulumi.set(__self__, "machine_type", machine_type)

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> str:
        return pulumi.get(self, "machine_type")


@pulumi.output_type
class EnvironmentConfigWebServerNetworkAccessControl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedIpRanges":
            suggest = "allowed_ip_ranges"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigWebServerNetworkAccessControl. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigWebServerNetworkAccessControl.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigWebServerNetworkAccessControl.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allowed_ip_ranges: Optional[Sequence['outputs.EnvironmentConfigWebServerNetworkAccessControlAllowedIpRange']] = None):
        if allowed_ip_ranges is not None:
            pulumi.set(__self__, "allowed_ip_ranges", allowed_ip_ranges)

    @property
    @pulumi.getter(name="allowedIpRanges")
    def allowed_ip_ranges(self) -> Optional[Sequence['outputs.EnvironmentConfigWebServerNetworkAccessControlAllowedIpRange']]:
        return pulumi.get(self, "allowed_ip_ranges")


@pulumi.output_type
class EnvironmentConfigWebServerNetworkAccessControlAllowedIpRange(dict):
    def __init__(__self__, *,
                 value: str,
                 description: Optional[str] = None):
        pulumi.set(__self__, "value", value)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")


@pulumi.output_type
class EnvironmentConfigWorkloadsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "webServer":
            suggest = "web_server"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigWorkloadsConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigWorkloadsConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigWorkloadsConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 scheduler: Optional['outputs.EnvironmentConfigWorkloadsConfigScheduler'] = None,
                 triggerer: Optional['outputs.EnvironmentConfigWorkloadsConfigTriggerer'] = None,
                 web_server: Optional['outputs.EnvironmentConfigWorkloadsConfigWebServer'] = None,
                 worker: Optional['outputs.EnvironmentConfigWorkloadsConfigWorker'] = None):
        if scheduler is not None:
            pulumi.set(__self__, "scheduler", scheduler)
        if triggerer is not None:
            pulumi.set(__self__, "triggerer", triggerer)
        if web_server is not None:
            pulumi.set(__self__, "web_server", web_server)
        if worker is not None:
            pulumi.set(__self__, "worker", worker)

    @property
    @pulumi.getter
    def scheduler(self) -> Optional['outputs.EnvironmentConfigWorkloadsConfigScheduler']:
        return pulumi.get(self, "scheduler")

    @property
    @pulumi.getter
    def triggerer(self) -> Optional['outputs.EnvironmentConfigWorkloadsConfigTriggerer']:
        return pulumi.get(self, "triggerer")

    @property
    @pulumi.getter(name="webServer")
    def web_server(self) -> Optional['outputs.EnvironmentConfigWorkloadsConfigWebServer']:
        return pulumi.get(self, "web_server")

    @property
    @pulumi.getter
    def worker(self) -> Optional['outputs.EnvironmentConfigWorkloadsConfigWorker']:
        return pulumi.get(self, "worker")


@pulumi.output_type
class EnvironmentConfigWorkloadsConfigScheduler(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "memoryGb":
            suggest = "memory_gb"
        elif key == "storageGb":
            suggest = "storage_gb"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigWorkloadsConfigScheduler. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigWorkloadsConfigScheduler.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigWorkloadsConfigScheduler.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 count: Optional[int] = None,
                 cpu: Optional[float] = None,
                 memory_gb: Optional[float] = None,
                 storage_gb: Optional[float] = None):
        if count is not None:
            pulumi.set(__self__, "count", count)
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if memory_gb is not None:
            pulumi.set(__self__, "memory_gb", memory_gb)
        if storage_gb is not None:
            pulumi.set(__self__, "storage_gb", storage_gb)

    @property
    @pulumi.getter
    def count(self) -> Optional[int]:
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def cpu(self) -> Optional[float]:
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="memoryGb")
    def memory_gb(self) -> Optional[float]:
        return pulumi.get(self, "memory_gb")

    @property
    @pulumi.getter(name="storageGb")
    def storage_gb(self) -> Optional[float]:
        return pulumi.get(self, "storage_gb")


@pulumi.output_type
class EnvironmentConfigWorkloadsConfigTriggerer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "memoryGb":
            suggest = "memory_gb"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigWorkloadsConfigTriggerer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigWorkloadsConfigTriggerer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigWorkloadsConfigTriggerer.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 count: int,
                 cpu: float,
                 memory_gb: float):
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "memory_gb", memory_gb)

    @property
    @pulumi.getter
    def count(self) -> int:
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def cpu(self) -> float:
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="memoryGb")
    def memory_gb(self) -> float:
        return pulumi.get(self, "memory_gb")


@pulumi.output_type
class EnvironmentConfigWorkloadsConfigWebServer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "memoryGb":
            suggest = "memory_gb"
        elif key == "storageGb":
            suggest = "storage_gb"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigWorkloadsConfigWebServer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigWorkloadsConfigWebServer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigWorkloadsConfigWebServer.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cpu: Optional[float] = None,
                 memory_gb: Optional[float] = None,
                 storage_gb: Optional[float] = None):
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if memory_gb is not None:
            pulumi.set(__self__, "memory_gb", memory_gb)
        if storage_gb is not None:
            pulumi.set(__self__, "storage_gb", storage_gb)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[float]:
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="memoryGb")
    def memory_gb(self) -> Optional[float]:
        return pulumi.get(self, "memory_gb")

    @property
    @pulumi.getter(name="storageGb")
    def storage_gb(self) -> Optional[float]:
        return pulumi.get(self, "storage_gb")


@pulumi.output_type
class EnvironmentConfigWorkloadsConfigWorker(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxCount":
            suggest = "max_count"
        elif key == "memoryGb":
            suggest = "memory_gb"
        elif key == "minCount":
            suggest = "min_count"
        elif key == "storageGb":
            suggest = "storage_gb"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EnvironmentConfigWorkloadsConfigWorker. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EnvironmentConfigWorkloadsConfigWorker.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EnvironmentConfigWorkloadsConfigWorker.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cpu: Optional[float] = None,
                 max_count: Optional[int] = None,
                 memory_gb: Optional[float] = None,
                 min_count: Optional[int] = None,
                 storage_gb: Optional[float] = None):
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if max_count is not None:
            pulumi.set(__self__, "max_count", max_count)
        if memory_gb is not None:
            pulumi.set(__self__, "memory_gb", memory_gb)
        if min_count is not None:
            pulumi.set(__self__, "min_count", min_count)
        if storage_gb is not None:
            pulumi.set(__self__, "storage_gb", storage_gb)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[float]:
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="maxCount")
    def max_count(self) -> Optional[int]:
        return pulumi.get(self, "max_count")

    @property
    @pulumi.getter(name="memoryGb")
    def memory_gb(self) -> Optional[float]:
        return pulumi.get(self, "memory_gb")

    @property
    @pulumi.getter(name="minCount")
    def min_count(self) -> Optional[int]:
        return pulumi.get(self, "min_count")

    @property
    @pulumi.getter(name="storageGb")
    def storage_gb(self) -> Optional[float]:
        return pulumi.get(self, "storage_gb")


@pulumi.output_type
class GetEnvironmentConfigResult(dict):
    def __init__(__self__, *,
                 airflow_uri: str,
                 dag_gcs_prefix: str,
                 database_configs: Sequence['outputs.GetEnvironmentConfigDatabaseConfigResult'],
                 encryption_configs: Sequence['outputs.GetEnvironmentConfigEncryptionConfigResult'],
                 environment_size: str,
                 gke_cluster: str,
                 maintenance_windows: Sequence['outputs.GetEnvironmentConfigMaintenanceWindowResult'],
                 master_authorized_networks_configs: Sequence['outputs.GetEnvironmentConfigMasterAuthorizedNetworksConfigResult'],
                 node_configs: Sequence['outputs.GetEnvironmentConfigNodeConfigResult'],
                 node_count: int,
                 private_environment_configs: Sequence['outputs.GetEnvironmentConfigPrivateEnvironmentConfigResult'],
                 recovery_configs: Sequence['outputs.GetEnvironmentConfigRecoveryConfigResult'],
                 software_configs: Sequence['outputs.GetEnvironmentConfigSoftwareConfigResult'],
                 web_server_configs: Sequence['outputs.GetEnvironmentConfigWebServerConfigResult'],
                 web_server_network_access_controls: Sequence['outputs.GetEnvironmentConfigWebServerNetworkAccessControlResult'],
                 workloads_configs: Sequence['outputs.GetEnvironmentConfigWorkloadsConfigResult']):
        pulumi.set(__self__, "airflow_uri", airflow_uri)
        pulumi.set(__self__, "dag_gcs_prefix", dag_gcs_prefix)
        pulumi.set(__self__, "database_configs", database_configs)
        pulumi.set(__self__, "encryption_configs", encryption_configs)
        pulumi.set(__self__, "environment_size", environment_size)
        pulumi.set(__self__, "gke_cluster", gke_cluster)
        pulumi.set(__self__, "maintenance_windows", maintenance_windows)
        pulumi.set(__self__, "master_authorized_networks_configs", master_authorized_networks_configs)
        pulumi.set(__self__, "node_configs", node_configs)
        pulumi.set(__self__, "node_count", node_count)
        pulumi.set(__self__, "private_environment_configs", private_environment_configs)
        pulumi.set(__self__, "recovery_configs", recovery_configs)
        pulumi.set(__self__, "software_configs", software_configs)
        pulumi.set(__self__, "web_server_configs", web_server_configs)
        pulumi.set(__self__, "web_server_network_access_controls", web_server_network_access_controls)
        pulumi.set(__self__, "workloads_configs", workloads_configs)

    @property
    @pulumi.getter(name="airflowUri")
    def airflow_uri(self) -> str:
        return pulumi.get(self, "airflow_uri")

    @property
    @pulumi.getter(name="dagGcsPrefix")
    def dag_gcs_prefix(self) -> str:
        return pulumi.get(self, "dag_gcs_prefix")

    @property
    @pulumi.getter(name="databaseConfigs")
    def database_configs(self) -> Sequence['outputs.GetEnvironmentConfigDatabaseConfigResult']:
        return pulumi.get(self, "database_configs")

    @property
    @pulumi.getter(name="encryptionConfigs")
    def encryption_configs(self) -> Sequence['outputs.GetEnvironmentConfigEncryptionConfigResult']:
        return pulumi.get(self, "encryption_configs")

    @property
    @pulumi.getter(name="environmentSize")
    def environment_size(self) -> str:
        return pulumi.get(self, "environment_size")

    @property
    @pulumi.getter(name="gkeCluster")
    def gke_cluster(self) -> str:
        return pulumi.get(self, "gke_cluster")

    @property
    @pulumi.getter(name="maintenanceWindows")
    def maintenance_windows(self) -> Sequence['outputs.GetEnvironmentConfigMaintenanceWindowResult']:
        return pulumi.get(self, "maintenance_windows")

    @property
    @pulumi.getter(name="masterAuthorizedNetworksConfigs")
    def master_authorized_networks_configs(self) -> Sequence['outputs.GetEnvironmentConfigMasterAuthorizedNetworksConfigResult']:
        return pulumi.get(self, "master_authorized_networks_configs")

    @property
    @pulumi.getter(name="nodeConfigs")
    def node_configs(self) -> Sequence['outputs.GetEnvironmentConfigNodeConfigResult']:
        return pulumi.get(self, "node_configs")

    @property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> int:
        return pulumi.get(self, "node_count")

    @property
    @pulumi.getter(name="privateEnvironmentConfigs")
    def private_environment_configs(self) -> Sequence['outputs.GetEnvironmentConfigPrivateEnvironmentConfigResult']:
        return pulumi.get(self, "private_environment_configs")

    @property
    @pulumi.getter(name="recoveryConfigs")
    def recovery_configs(self) -> Sequence['outputs.GetEnvironmentConfigRecoveryConfigResult']:
        return pulumi.get(self, "recovery_configs")

    @property
    @pulumi.getter(name="softwareConfigs")
    def software_configs(self) -> Sequence['outputs.GetEnvironmentConfigSoftwareConfigResult']:
        return pulumi.get(self, "software_configs")

    @property
    @pulumi.getter(name="webServerConfigs")
    def web_server_configs(self) -> Sequence['outputs.GetEnvironmentConfigWebServerConfigResult']:
        return pulumi.get(self, "web_server_configs")

    @property
    @pulumi.getter(name="webServerNetworkAccessControls")
    def web_server_network_access_controls(self) -> Sequence['outputs.GetEnvironmentConfigWebServerNetworkAccessControlResult']:
        return pulumi.get(self, "web_server_network_access_controls")

    @property
    @pulumi.getter(name="workloadsConfigs")
    def workloads_configs(self) -> Sequence['outputs.GetEnvironmentConfigWorkloadsConfigResult']:
        return pulumi.get(self, "workloads_configs")


@pulumi.output_type
class GetEnvironmentConfigDatabaseConfigResult(dict):
    def __init__(__self__, *,
                 machine_type: str):
        pulumi.set(__self__, "machine_type", machine_type)

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> str:
        return pulumi.get(self, "machine_type")


@pulumi.output_type
class GetEnvironmentConfigEncryptionConfigResult(dict):
    def __init__(__self__, *,
                 kms_key_name: str):
        pulumi.set(__self__, "kms_key_name", kms_key_name)

    @property
    @pulumi.getter(name="kmsKeyName")
    def kms_key_name(self) -> str:
        return pulumi.get(self, "kms_key_name")


@pulumi.output_type
class GetEnvironmentConfigMaintenanceWindowResult(dict):
    def __init__(__self__, *,
                 end_time: str,
                 recurrence: str,
                 start_time: str):
        pulumi.set(__self__, "end_time", end_time)
        pulumi.set(__self__, "recurrence", recurrence)
        pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> str:
        return pulumi.get(self, "end_time")

    @property
    @pulumi.getter
    def recurrence(self) -> str:
        return pulumi.get(self, "recurrence")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> str:
        return pulumi.get(self, "start_time")


@pulumi.output_type
class GetEnvironmentConfigMasterAuthorizedNetworksConfigResult(dict):
    def __init__(__self__, *,
                 cidr_blocks: Sequence['outputs.GetEnvironmentConfigMasterAuthorizedNetworksConfigCidrBlockResult'],
                 enabled: bool):
        pulumi.set(__self__, "cidr_blocks", cidr_blocks)
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="cidrBlocks")
    def cidr_blocks(self) -> Sequence['outputs.GetEnvironmentConfigMasterAuthorizedNetworksConfigCidrBlockResult']:
        return pulumi.get(self, "cidr_blocks")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetEnvironmentConfigMasterAuthorizedNetworksConfigCidrBlockResult(dict):
    def __init__(__self__, *,
                 cidr_block: str,
                 display_name: str):
        pulumi.set(__self__, "cidr_block", cidr_block)
        pulumi.set(__self__, "display_name", display_name)

    @property
    @pulumi.getter(name="cidrBlock")
    def cidr_block(self) -> str:
        return pulumi.get(self, "cidr_block")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        return pulumi.get(self, "display_name")


@pulumi.output_type
class GetEnvironmentConfigNodeConfigResult(dict):
    def __init__(__self__, *,
                 disk_size_gb: int,
                 enable_ip_masq_agent: bool,
                 ip_allocation_policies: Sequence['outputs.GetEnvironmentConfigNodeConfigIpAllocationPolicyResult'],
                 machine_type: str,
                 max_pods_per_node: int,
                 network: str,
                 oauth_scopes: Sequence[str],
                 service_account: str,
                 subnetwork: str,
                 tags: Sequence[str],
                 zone: str):
        pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        pulumi.set(__self__, "enable_ip_masq_agent", enable_ip_masq_agent)
        pulumi.set(__self__, "ip_allocation_policies", ip_allocation_policies)
        pulumi.set(__self__, "machine_type", machine_type)
        pulumi.set(__self__, "max_pods_per_node", max_pods_per_node)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "oauth_scopes", oauth_scopes)
        pulumi.set(__self__, "service_account", service_account)
        pulumi.set(__self__, "subnetwork", subnetwork)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "zone", zone)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> int:
        return pulumi.get(self, "disk_size_gb")

    @property
    @pulumi.getter(name="enableIpMasqAgent")
    def enable_ip_masq_agent(self) -> bool:
        return pulumi.get(self, "enable_ip_masq_agent")

    @property
    @pulumi.getter(name="ipAllocationPolicies")
    def ip_allocation_policies(self) -> Sequence['outputs.GetEnvironmentConfigNodeConfigIpAllocationPolicyResult']:
        return pulumi.get(self, "ip_allocation_policies")

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> str:
        return pulumi.get(self, "machine_type")

    @property
    @pulumi.getter(name="maxPodsPerNode")
    def max_pods_per_node(self) -> int:
        return pulumi.get(self, "max_pods_per_node")

    @property
    @pulumi.getter
    def network(self) -> str:
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> Sequence[str]:
        return pulumi.get(self, "oauth_scopes")

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> str:
        return pulumi.get(self, "service_account")

    @property
    @pulumi.getter
    def subnetwork(self) -> str:
        return pulumi.get(self, "subnetwork")

    @property
    @pulumi.getter
    def tags(self) -> Sequence[str]:
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def zone(self) -> str:
        return pulumi.get(self, "zone")


@pulumi.output_type
class GetEnvironmentConfigNodeConfigIpAllocationPolicyResult(dict):
    def __init__(__self__, *,
                 cluster_ipv4_cidr_block: str,
                 cluster_secondary_range_name: str,
                 services_ipv4_cidr_block: str,
                 services_secondary_range_name: str,
                 use_ip_aliases: bool):
        pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
        pulumi.set(__self__, "cluster_secondary_range_name", cluster_secondary_range_name)
        pulumi.set(__self__, "services_ipv4_cidr_block", services_ipv4_cidr_block)
        pulumi.set(__self__, "services_secondary_range_name", services_secondary_range_name)
        pulumi.set(__self__, "use_ip_aliases", use_ip_aliases)

    @property
    @pulumi.getter(name="clusterIpv4CidrBlock")
    def cluster_ipv4_cidr_block(self) -> str:
        return pulumi.get(self, "cluster_ipv4_cidr_block")

    @property
    @pulumi.getter(name="clusterSecondaryRangeName")
    def cluster_secondary_range_name(self) -> str:
        return pulumi.get(self, "cluster_secondary_range_name")

    @property
    @pulumi.getter(name="servicesIpv4CidrBlock")
    def services_ipv4_cidr_block(self) -> str:
        return pulumi.get(self, "services_ipv4_cidr_block")

    @property
    @pulumi.getter(name="servicesSecondaryRangeName")
    def services_secondary_range_name(self) -> str:
        return pulumi.get(self, "services_secondary_range_name")

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> bool:
        return pulumi.get(self, "use_ip_aliases")


@pulumi.output_type
class GetEnvironmentConfigPrivateEnvironmentConfigResult(dict):
    def __init__(__self__, *,
                 cloud_composer_connection_subnetwork: str,
                 cloud_composer_network_ipv4_cidr_block: str,
                 cloud_sql_ipv4_cidr_block: str,
                 enable_private_endpoint: bool,
                 enable_privately_used_public_ips: bool,
                 master_ipv4_cidr_block: str,
                 web_server_ipv4_cidr_block: str):
        pulumi.set(__self__, "cloud_composer_connection_subnetwork", cloud_composer_connection_subnetwork)
        pulumi.set(__self__, "cloud_composer_network_ipv4_cidr_block", cloud_composer_network_ipv4_cidr_block)
        pulumi.set(__self__, "cloud_sql_ipv4_cidr_block", cloud_sql_ipv4_cidr_block)
        pulumi.set(__self__, "enable_private_endpoint", enable_private_endpoint)
        pulumi.set(__self__, "enable_privately_used_public_ips", enable_privately_used_public_ips)
        pulumi.set(__self__, "master_ipv4_cidr_block", master_ipv4_cidr_block)
        pulumi.set(__self__, "web_server_ipv4_cidr_block", web_server_ipv4_cidr_block)

    @property
    @pulumi.getter(name="cloudComposerConnectionSubnetwork")
    def cloud_composer_connection_subnetwork(self) -> str:
        return pulumi.get(self, "cloud_composer_connection_subnetwork")

    @property
    @pulumi.getter(name="cloudComposerNetworkIpv4CidrBlock")
    def cloud_composer_network_ipv4_cidr_block(self) -> str:
        return pulumi.get(self, "cloud_composer_network_ipv4_cidr_block")

    @property
    @pulumi.getter(name="cloudSqlIpv4CidrBlock")
    def cloud_sql_ipv4_cidr_block(self) -> str:
        return pulumi.get(self, "cloud_sql_ipv4_cidr_block")

    @property
    @pulumi.getter(name="enablePrivateEndpoint")
    def enable_private_endpoint(self) -> bool:
        return pulumi.get(self, "enable_private_endpoint")

    @property
    @pulumi.getter(name="enablePrivatelyUsedPublicIps")
    def enable_privately_used_public_ips(self) -> bool:
        return pulumi.get(self, "enable_privately_used_public_ips")

    @property
    @pulumi.getter(name="masterIpv4CidrBlock")
    def master_ipv4_cidr_block(self) -> str:
        return pulumi.get(self, "master_ipv4_cidr_block")

    @property
    @pulumi.getter(name="webServerIpv4CidrBlock")
    def web_server_ipv4_cidr_block(self) -> str:
        return pulumi.get(self, "web_server_ipv4_cidr_block")


@pulumi.output_type
class GetEnvironmentConfigRecoveryConfigResult(dict):
    def __init__(__self__, *,
                 scheduled_snapshots_configs: Sequence['outputs.GetEnvironmentConfigRecoveryConfigScheduledSnapshotsConfigResult']):
        pulumi.set(__self__, "scheduled_snapshots_configs", scheduled_snapshots_configs)

    @property
    @pulumi.getter(name="scheduledSnapshotsConfigs")
    def scheduled_snapshots_configs(self) -> Sequence['outputs.GetEnvironmentConfigRecoveryConfigScheduledSnapshotsConfigResult']:
        return pulumi.get(self, "scheduled_snapshots_configs")


@pulumi.output_type
class GetEnvironmentConfigRecoveryConfigScheduledSnapshotsConfigResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 snapshot_creation_schedule: str,
                 snapshot_location: str,
                 time_zone: str):
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "snapshot_creation_schedule", snapshot_creation_schedule)
        pulumi.set(__self__, "snapshot_location", snapshot_location)
        pulumi.set(__self__, "time_zone", time_zone)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="snapshotCreationSchedule")
    def snapshot_creation_schedule(self) -> str:
        return pulumi.get(self, "snapshot_creation_schedule")

    @property
    @pulumi.getter(name="snapshotLocation")
    def snapshot_location(self) -> str:
        return pulumi.get(self, "snapshot_location")

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> str:
        return pulumi.get(self, "time_zone")


@pulumi.output_type
class GetEnvironmentConfigSoftwareConfigResult(dict):
    def __init__(__self__, *,
                 airflow_config_overrides: Mapping[str, str],
                 cloud_data_lineage_integrations: Sequence['outputs.GetEnvironmentConfigSoftwareConfigCloudDataLineageIntegrationResult'],
                 env_variables: Mapping[str, str],
                 image_version: str,
                 pypi_packages: Mapping[str, str],
                 python_version: str,
                 scheduler_count: int):
        pulumi.set(__self__, "airflow_config_overrides", airflow_config_overrides)
        pulumi.set(__self__, "cloud_data_lineage_integrations", cloud_data_lineage_integrations)
        pulumi.set(__self__, "env_variables", env_variables)
        pulumi.set(__self__, "image_version", image_version)
        pulumi.set(__self__, "pypi_packages", pypi_packages)
        pulumi.set(__self__, "python_version", python_version)
        pulumi.set(__self__, "scheduler_count", scheduler_count)

    @property
    @pulumi.getter(name="airflowConfigOverrides")
    def airflow_config_overrides(self) -> Mapping[str, str]:
        return pulumi.get(self, "airflow_config_overrides")

    @property
    @pulumi.getter(name="cloudDataLineageIntegrations")
    def cloud_data_lineage_integrations(self) -> Sequence['outputs.GetEnvironmentConfigSoftwareConfigCloudDataLineageIntegrationResult']:
        return pulumi.get(self, "cloud_data_lineage_integrations")

    @property
    @pulumi.getter(name="envVariables")
    def env_variables(self) -> Mapping[str, str]:
        return pulumi.get(self, "env_variables")

    @property
    @pulumi.getter(name="imageVersion")
    def image_version(self) -> str:
        return pulumi.get(self, "image_version")

    @property
    @pulumi.getter(name="pypiPackages")
    def pypi_packages(self) -> Mapping[str, str]:
        return pulumi.get(self, "pypi_packages")

    @property
    @pulumi.getter(name="pythonVersion")
    def python_version(self) -> str:
        return pulumi.get(self, "python_version")

    @property
    @pulumi.getter(name="schedulerCount")
    def scheduler_count(self) -> int:
        return pulumi.get(self, "scheduler_count")


@pulumi.output_type
class GetEnvironmentConfigSoftwareConfigCloudDataLineageIntegrationResult(dict):
    def __init__(__self__, *,
                 enabled: bool):
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetEnvironmentConfigWebServerConfigResult(dict):
    def __init__(__self__, *,
                 machine_type: str):
        pulumi.set(__self__, "machine_type", machine_type)

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> str:
        return pulumi.get(self, "machine_type")


@pulumi.output_type
class GetEnvironmentConfigWebServerNetworkAccessControlResult(dict):
    def __init__(__self__, *,
                 allowed_ip_ranges: Sequence['outputs.GetEnvironmentConfigWebServerNetworkAccessControlAllowedIpRangeResult']):
        pulumi.set(__self__, "allowed_ip_ranges", allowed_ip_ranges)

    @property
    @pulumi.getter(name="allowedIpRanges")
    def allowed_ip_ranges(self) -> Sequence['outputs.GetEnvironmentConfigWebServerNetworkAccessControlAllowedIpRangeResult']:
        return pulumi.get(self, "allowed_ip_ranges")


@pulumi.output_type
class GetEnvironmentConfigWebServerNetworkAccessControlAllowedIpRangeResult(dict):
    def __init__(__self__, *,
                 description: str,
                 value: str):
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def description(self) -> str:
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetEnvironmentConfigWorkloadsConfigResult(dict):
    def __init__(__self__, *,
                 schedulers: Sequence['outputs.GetEnvironmentConfigWorkloadsConfigSchedulerResult'],
                 triggerers: Sequence['outputs.GetEnvironmentConfigWorkloadsConfigTriggererResult'],
                 web_servers: Sequence['outputs.GetEnvironmentConfigWorkloadsConfigWebServerResult'],
                 workers: Sequence['outputs.GetEnvironmentConfigWorkloadsConfigWorkerResult']):
        pulumi.set(__self__, "schedulers", schedulers)
        pulumi.set(__self__, "triggerers", triggerers)
        pulumi.set(__self__, "web_servers", web_servers)
        pulumi.set(__self__, "workers", workers)

    @property
    @pulumi.getter
    def schedulers(self) -> Sequence['outputs.GetEnvironmentConfigWorkloadsConfigSchedulerResult']:
        return pulumi.get(self, "schedulers")

    @property
    @pulumi.getter
    def triggerers(self) -> Sequence['outputs.GetEnvironmentConfigWorkloadsConfigTriggererResult']:
        return pulumi.get(self, "triggerers")

    @property
    @pulumi.getter(name="webServers")
    def web_servers(self) -> Sequence['outputs.GetEnvironmentConfigWorkloadsConfigWebServerResult']:
        return pulumi.get(self, "web_servers")

    @property
    @pulumi.getter
    def workers(self) -> Sequence['outputs.GetEnvironmentConfigWorkloadsConfigWorkerResult']:
        return pulumi.get(self, "workers")


@pulumi.output_type
class GetEnvironmentConfigWorkloadsConfigSchedulerResult(dict):
    def __init__(__self__, *,
                 count: int,
                 cpu: float,
                 memory_gb: float,
                 storage_gb: float):
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "memory_gb", memory_gb)
        pulumi.set(__self__, "storage_gb", storage_gb)

    @property
    @pulumi.getter
    def count(self) -> int:
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def cpu(self) -> float:
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="memoryGb")
    def memory_gb(self) -> float:
        return pulumi.get(self, "memory_gb")

    @property
    @pulumi.getter(name="storageGb")
    def storage_gb(self) -> float:
        return pulumi.get(self, "storage_gb")


@pulumi.output_type
class GetEnvironmentConfigWorkloadsConfigTriggererResult(dict):
    def __init__(__self__, *,
                 count: int,
                 cpu: float,
                 memory_gb: float):
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "memory_gb", memory_gb)

    @property
    @pulumi.getter
    def count(self) -> int:
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def cpu(self) -> float:
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="memoryGb")
    def memory_gb(self) -> float:
        return pulumi.get(self, "memory_gb")


@pulumi.output_type
class GetEnvironmentConfigWorkloadsConfigWebServerResult(dict):
    def __init__(__self__, *,
                 cpu: float,
                 memory_gb: float,
                 storage_gb: float):
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "memory_gb", memory_gb)
        pulumi.set(__self__, "storage_gb", storage_gb)

    @property
    @pulumi.getter
    def cpu(self) -> float:
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="memoryGb")
    def memory_gb(self) -> float:
        return pulumi.get(self, "memory_gb")

    @property
    @pulumi.getter(name="storageGb")
    def storage_gb(self) -> float:
        return pulumi.get(self, "storage_gb")


@pulumi.output_type
class GetEnvironmentConfigWorkloadsConfigWorkerResult(dict):
    def __init__(__self__, *,
                 cpu: float,
                 max_count: int,
                 memory_gb: float,
                 min_count: int,
                 storage_gb: float):
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "max_count", max_count)
        pulumi.set(__self__, "memory_gb", memory_gb)
        pulumi.set(__self__, "min_count", min_count)
        pulumi.set(__self__, "storage_gb", storage_gb)

    @property
    @pulumi.getter
    def cpu(self) -> float:
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="maxCount")
    def max_count(self) -> int:
        return pulumi.get(self, "max_count")

    @property
    @pulumi.getter(name="memoryGb")
    def memory_gb(self) -> float:
        return pulumi.get(self, "memory_gb")

    @property
    @pulumi.getter(name="minCount")
    def min_count(self) -> int:
        return pulumi.get(self, "min_count")

    @property
    @pulumi.getter(name="storageGb")
    def storage_gb(self) -> float:
        return pulumi.get(self, "storage_gb")


@pulumi.output_type
class GetImageVersionsImageVersionResult(dict):
    def __init__(__self__, *,
                 image_version_id: str,
                 supported_python_versions: Sequence[str]):
        """
        :param str image_version_id: The string identifier of the image version, in the form: "composer-x.y.z-airflow-a.b.c"
        :param Sequence[str] supported_python_versions: Supported python versions for this image version
        """
        pulumi.set(__self__, "image_version_id", image_version_id)
        pulumi.set(__self__, "supported_python_versions", supported_python_versions)

    @property
    @pulumi.getter(name="imageVersionId")
    def image_version_id(self) -> str:
        """
        The string identifier of the image version, in the form: "composer-x.y.z-airflow-a.b.c"
        """
        return pulumi.get(self, "image_version_id")

    @property
    @pulumi.getter(name="supportedPythonVersions")
    def supported_python_versions(self) -> Sequence[str]:
        """
        Supported python versions for this image version
        """
        return pulumi.get(self, "supported_python_versions")


