# 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

__all__ = [
    'EnvironmentConfigArgs',
    'EnvironmentConfigDatabaseConfigArgs',
    'EnvironmentConfigEncryptionConfigArgs',
    'EnvironmentConfigMaintenanceWindowArgs',
    'EnvironmentConfigMasterAuthorizedNetworksConfigArgs',
    'EnvironmentConfigMasterAuthorizedNetworksConfigCidrBlockArgs',
    'EnvironmentConfigNodeConfigArgs',
    'EnvironmentConfigNodeConfigIpAllocationPolicyArgs',
    'EnvironmentConfigPrivateEnvironmentConfigArgs',
    'EnvironmentConfigRecoveryConfigArgs',
    'EnvironmentConfigRecoveryConfigScheduledSnapshotsConfigArgs',
    'EnvironmentConfigSoftwareConfigArgs',
    'EnvironmentConfigSoftwareConfigCloudDataLineageIntegrationArgs',
    'EnvironmentConfigWebServerConfigArgs',
    'EnvironmentConfigWebServerNetworkAccessControlArgs',
    'EnvironmentConfigWebServerNetworkAccessControlAllowedIpRangeArgs',
    'EnvironmentConfigWorkloadsConfigArgs',
    'EnvironmentConfigWorkloadsConfigSchedulerArgs',
    'EnvironmentConfigWorkloadsConfigTriggererArgs',
    'EnvironmentConfigWorkloadsConfigWebServerArgs',
    'EnvironmentConfigWorkloadsConfigWorkerArgs',
]

@pulumi.input_type
class EnvironmentConfigArgs:
    def __init__(__self__, *,
                 airflow_uri: Optional[pulumi.Input[str]] = None,
                 dag_gcs_prefix: Optional[pulumi.Input[str]] = None,
                 database_config: Optional[pulumi.Input['EnvironmentConfigDatabaseConfigArgs']] = None,
                 encryption_config: Optional[pulumi.Input['EnvironmentConfigEncryptionConfigArgs']] = None,
                 environment_size: Optional[pulumi.Input[str]] = None,
                 gke_cluster: Optional[pulumi.Input[str]] = None,
                 maintenance_window: Optional[pulumi.Input['EnvironmentConfigMaintenanceWindowArgs']] = None,
                 master_authorized_networks_config: Optional[pulumi.Input['EnvironmentConfigMasterAuthorizedNetworksConfigArgs']] = None,
                 node_config: Optional[pulumi.Input['EnvironmentConfigNodeConfigArgs']] = None,
                 node_count: Optional[pulumi.Input[int]] = None,
                 private_environment_config: Optional[pulumi.Input['EnvironmentConfigPrivateEnvironmentConfigArgs']] = None,
                 recovery_config: Optional[pulumi.Input['EnvironmentConfigRecoveryConfigArgs']] = None,
                 software_config: Optional[pulumi.Input['EnvironmentConfigSoftwareConfigArgs']] = None,
                 web_server_config: Optional[pulumi.Input['EnvironmentConfigWebServerConfigArgs']] = None,
                 web_server_network_access_control: Optional[pulumi.Input['EnvironmentConfigWebServerNetworkAccessControlArgs']] = None,
                 workloads_config: Optional[pulumi.Input['EnvironmentConfigWorkloadsConfigArgs']] = 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[pulumi.Input[str]]:
        return pulumi.get(self, "airflow_uri")

    @airflow_uri.setter
    def airflow_uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "airflow_uri", value)

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

    @dag_gcs_prefix.setter
    def dag_gcs_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dag_gcs_prefix", value)

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

    @database_config.setter
    def database_config(self, value: Optional[pulumi.Input['EnvironmentConfigDatabaseConfigArgs']]):
        pulumi.set(self, "database_config", value)

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

    @encryption_config.setter
    def encryption_config(self, value: Optional[pulumi.Input['EnvironmentConfigEncryptionConfigArgs']]):
        pulumi.set(self, "encryption_config", value)

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

    @environment_size.setter
    def environment_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "environment_size", value)

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

    @gke_cluster.setter
    def gke_cluster(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gke_cluster", value)

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

    @maintenance_window.setter
    def maintenance_window(self, value: Optional[pulumi.Input['EnvironmentConfigMaintenanceWindowArgs']]):
        pulumi.set(self, "maintenance_window", value)

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

    @master_authorized_networks_config.setter
    def master_authorized_networks_config(self, value: Optional[pulumi.Input['EnvironmentConfigMasterAuthorizedNetworksConfigArgs']]):
        pulumi.set(self, "master_authorized_networks_config", value)

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

    @node_config.setter
    def node_config(self, value: Optional[pulumi.Input['EnvironmentConfigNodeConfigArgs']]):
        pulumi.set(self, "node_config", value)

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

    @node_count.setter
    def node_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "node_count", value)

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

    @private_environment_config.setter
    def private_environment_config(self, value: Optional[pulumi.Input['EnvironmentConfigPrivateEnvironmentConfigArgs']]):
        pulumi.set(self, "private_environment_config", value)

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

    @recovery_config.setter
    def recovery_config(self, value: Optional[pulumi.Input['EnvironmentConfigRecoveryConfigArgs']]):
        pulumi.set(self, "recovery_config", value)

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

    @software_config.setter
    def software_config(self, value: Optional[pulumi.Input['EnvironmentConfigSoftwareConfigArgs']]):
        pulumi.set(self, "software_config", value)

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

    @web_server_config.setter
    def web_server_config(self, value: Optional[pulumi.Input['EnvironmentConfigWebServerConfigArgs']]):
        pulumi.set(self, "web_server_config", value)

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

    @web_server_network_access_control.setter
    def web_server_network_access_control(self, value: Optional[pulumi.Input['EnvironmentConfigWebServerNetworkAccessControlArgs']]):
        pulumi.set(self, "web_server_network_access_control", value)

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

    @workloads_config.setter
    def workloads_config(self, value: Optional[pulumi.Input['EnvironmentConfigWorkloadsConfigArgs']]):
        pulumi.set(self, "workloads_config", value)


@pulumi.input_type
class EnvironmentConfigDatabaseConfigArgs:
    def __init__(__self__, *,
                 machine_type: pulumi.Input[str]):
        pulumi.set(__self__, "machine_type", machine_type)

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

    @machine_type.setter
    def machine_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "machine_type", value)


@pulumi.input_type
class EnvironmentConfigEncryptionConfigArgs:
    def __init__(__self__, *,
                 kms_key_name: pulumi.Input[str]):
        pulumi.set(__self__, "kms_key_name", kms_key_name)

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

    @kms_key_name.setter
    def kms_key_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "kms_key_name", value)


@pulumi.input_type
class EnvironmentConfigMaintenanceWindowArgs:
    def __init__(__self__, *,
                 end_time: pulumi.Input[str],
                 recurrence: pulumi.Input[str],
                 start_time: pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "end_time")

    @end_time.setter
    def end_time(self, value: pulumi.Input[str]):
        pulumi.set(self, "end_time", value)

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

    @recurrence.setter
    def recurrence(self, value: pulumi.Input[str]):
        pulumi.set(self, "recurrence", value)

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

    @start_time.setter
    def start_time(self, value: pulumi.Input[str]):
        pulumi.set(self, "start_time", value)


@pulumi.input_type
class EnvironmentConfigMasterAuthorizedNetworksConfigArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool],
                 cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentConfigMasterAuthorizedNetworksConfigCidrBlockArgs']]]] = 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) -> pulumi.Input[bool]:
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enabled", value)

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

    @cidr_blocks.setter
    def cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentConfigMasterAuthorizedNetworksConfigCidrBlockArgs']]]]):
        pulumi.set(self, "cidr_blocks", value)


@pulumi.input_type
class EnvironmentConfigMasterAuthorizedNetworksConfigCidrBlockArgs:
    def __init__(__self__, *,
                 cidr_block: pulumi.Input[str],
                 display_name: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "cidr_block")

    @cidr_block.setter
    def cidr_block(self, value: pulumi.Input[str]):
        pulumi.set(self, "cidr_block", value)

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

    @display_name.setter
    def display_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "display_name", value)


@pulumi.input_type
class EnvironmentConfigNodeConfigArgs:
    def __init__(__self__, *,
                 disk_size_gb: Optional[pulumi.Input[int]] = None,
                 enable_ip_masq_agent: Optional[pulumi.Input[bool]] = None,
                 ip_allocation_policy: Optional[pulumi.Input['EnvironmentConfigNodeConfigIpAllocationPolicyArgs']] = None,
                 machine_type: Optional[pulumi.Input[str]] = None,
                 max_pods_per_node: Optional[pulumi.Input[int]] = None,
                 network: Optional[pulumi.Input[str]] = None,
                 oauth_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 service_account: Optional[pulumi.Input[str]] = None,
                 subnetwork: Optional[pulumi.Input[str]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 zone: Optional[pulumi.Input[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[pulumi.Input[int]]:
        return pulumi.get(self, "disk_size_gb")

    @disk_size_gb.setter
    def disk_size_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "disk_size_gb", value)

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

    @enable_ip_masq_agent.setter
    def enable_ip_masq_agent(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_ip_masq_agent", value)

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

    @ip_allocation_policy.setter
    def ip_allocation_policy(self, value: Optional[pulumi.Input['EnvironmentConfigNodeConfigIpAllocationPolicyArgs']]):
        pulumi.set(self, "ip_allocation_policy", value)

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

    @machine_type.setter
    def machine_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "machine_type", value)

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

    @max_pods_per_node.setter
    def max_pods_per_node(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_pods_per_node", value)

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

    @network.setter
    def network(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network", value)

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

    @oauth_scopes.setter
    def oauth_scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "oauth_scopes", value)

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

    @service_account.setter
    def service_account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_account", value)

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

    @subnetwork.setter
    def subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subnetwork", value)

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

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)

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

    @zone.setter
    def zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "zone", value)


@pulumi.input_type
class EnvironmentConfigNodeConfigIpAllocationPolicyArgs:
    def __init__(__self__, *,
                 cluster_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 cluster_secondary_range_name: Optional[pulumi.Input[str]] = None,
                 services_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 services_secondary_range_name: Optional[pulumi.Input[str]] = None,
                 use_ip_aliases: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "cluster_ipv4_cidr_block")

    @cluster_ipv4_cidr_block.setter
    def cluster_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_ipv4_cidr_block", value)

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

    @cluster_secondary_range_name.setter
    def cluster_secondary_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_secondary_range_name", value)

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

    @services_ipv4_cidr_block.setter
    def services_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_ipv4_cidr_block", value)

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

    @services_secondary_range_name.setter
    def services_secondary_range_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "services_secondary_range_name", value)

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

    @use_ip_aliases.setter
    def use_ip_aliases(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_ip_aliases", value)


@pulumi.input_type
class EnvironmentConfigPrivateEnvironmentConfigArgs:
    def __init__(__self__, *,
                 cloud_composer_connection_subnetwork: Optional[pulumi.Input[str]] = None,
                 cloud_composer_network_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 cloud_sql_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 enable_private_endpoint: Optional[pulumi.Input[bool]] = None,
                 enable_privately_used_public_ips: Optional[pulumi.Input[bool]] = None,
                 master_ipv4_cidr_block: Optional[pulumi.Input[str]] = None,
                 web_server_ipv4_cidr_block: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "cloud_composer_connection_subnetwork")

    @cloud_composer_connection_subnetwork.setter
    def cloud_composer_connection_subnetwork(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud_composer_connection_subnetwork", value)

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

    @cloud_composer_network_ipv4_cidr_block.setter
    def cloud_composer_network_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud_composer_network_ipv4_cidr_block", value)

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

    @cloud_sql_ipv4_cidr_block.setter
    def cloud_sql_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud_sql_ipv4_cidr_block", value)

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

    @enable_private_endpoint.setter
    def enable_private_endpoint(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_private_endpoint", value)

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

    @enable_privately_used_public_ips.setter
    def enable_privately_used_public_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_privately_used_public_ips", value)

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

    @master_ipv4_cidr_block.setter
    def master_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "master_ipv4_cidr_block", value)

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

    @web_server_ipv4_cidr_block.setter
    def web_server_ipv4_cidr_block(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "web_server_ipv4_cidr_block", value)


@pulumi.input_type
class EnvironmentConfigRecoveryConfigArgs:
    def __init__(__self__, *,
                 scheduled_snapshots_config: Optional[pulumi.Input['EnvironmentConfigRecoveryConfigScheduledSnapshotsConfigArgs']] = 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[pulumi.Input['EnvironmentConfigRecoveryConfigScheduledSnapshotsConfigArgs']]:
        return pulumi.get(self, "scheduled_snapshots_config")

    @scheduled_snapshots_config.setter
    def scheduled_snapshots_config(self, value: Optional[pulumi.Input['EnvironmentConfigRecoveryConfigScheduledSnapshotsConfigArgs']]):
        pulumi.set(self, "scheduled_snapshots_config", value)


@pulumi.input_type
class EnvironmentConfigRecoveryConfigScheduledSnapshotsConfigArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool],
                 snapshot_creation_schedule: Optional[pulumi.Input[str]] = None,
                 snapshot_location: Optional[pulumi.Input[str]] = None,
                 time_zone: Optional[pulumi.Input[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) -> pulumi.Input[bool]:
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enabled", value)

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

    @snapshot_creation_schedule.setter
    def snapshot_creation_schedule(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "snapshot_creation_schedule", value)

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

    @snapshot_location.setter
    def snapshot_location(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "snapshot_location", value)

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

    @time_zone.setter
    def time_zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "time_zone", value)


@pulumi.input_type
class EnvironmentConfigSoftwareConfigArgs:
    def __init__(__self__, *,
                 airflow_config_overrides: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 cloud_data_lineage_integration: Optional[pulumi.Input['EnvironmentConfigSoftwareConfigCloudDataLineageIntegrationArgs']] = None,
                 env_variables: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 image_version: Optional[pulumi.Input[str]] = None,
                 pypi_packages: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 python_version: Optional[pulumi.Input[str]] = None,
                 scheduler_count: Optional[pulumi.Input[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[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        return pulumi.get(self, "airflow_config_overrides")

    @airflow_config_overrides.setter
    def airflow_config_overrides(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "airflow_config_overrides", value)

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

    @cloud_data_lineage_integration.setter
    def cloud_data_lineage_integration(self, value: Optional[pulumi.Input['EnvironmentConfigSoftwareConfigCloudDataLineageIntegrationArgs']]):
        pulumi.set(self, "cloud_data_lineage_integration", value)

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

    @env_variables.setter
    def env_variables(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "env_variables", value)

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

    @image_version.setter
    def image_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "image_version", value)

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

    @pypi_packages.setter
    def pypi_packages(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "pypi_packages", value)

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

    @python_version.setter
    def python_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "python_version", value)

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

    @scheduler_count.setter
    def scheduler_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "scheduler_count", value)


@pulumi.input_type
class EnvironmentConfigSoftwareConfigCloudDataLineageIntegrationArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool]):
        pulumi.set(__self__, "enabled", enabled)

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

    @enabled.setter
    def enabled(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class EnvironmentConfigWebServerConfigArgs:
    def __init__(__self__, *,
                 machine_type: pulumi.Input[str]):
        pulumi.set(__self__, "machine_type", machine_type)

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

    @machine_type.setter
    def machine_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "machine_type", value)


@pulumi.input_type
class EnvironmentConfigWebServerNetworkAccessControlArgs:
    def __init__(__self__, *,
                 allowed_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentConfigWebServerNetworkAccessControlAllowedIpRangeArgs']]]] = 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[pulumi.Input[Sequence[pulumi.Input['EnvironmentConfigWebServerNetworkAccessControlAllowedIpRangeArgs']]]]:
        return pulumi.get(self, "allowed_ip_ranges")

    @allowed_ip_ranges.setter
    def allowed_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EnvironmentConfigWebServerNetworkAccessControlAllowedIpRangeArgs']]]]):
        pulumi.set(self, "allowed_ip_ranges", value)


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

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class EnvironmentConfigWorkloadsConfigArgs:
    def __init__(__self__, *,
                 scheduler: Optional[pulumi.Input['EnvironmentConfigWorkloadsConfigSchedulerArgs']] = None,
                 triggerer: Optional[pulumi.Input['EnvironmentConfigWorkloadsConfigTriggererArgs']] = None,
                 web_server: Optional[pulumi.Input['EnvironmentConfigWorkloadsConfigWebServerArgs']] = None,
                 worker: Optional[pulumi.Input['EnvironmentConfigWorkloadsConfigWorkerArgs']] = 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[pulumi.Input['EnvironmentConfigWorkloadsConfigSchedulerArgs']]:
        return pulumi.get(self, "scheduler")

    @scheduler.setter
    def scheduler(self, value: Optional[pulumi.Input['EnvironmentConfigWorkloadsConfigSchedulerArgs']]):
        pulumi.set(self, "scheduler", value)

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

    @triggerer.setter
    def triggerer(self, value: Optional[pulumi.Input['EnvironmentConfigWorkloadsConfigTriggererArgs']]):
        pulumi.set(self, "triggerer", value)

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

    @web_server.setter
    def web_server(self, value: Optional[pulumi.Input['EnvironmentConfigWorkloadsConfigWebServerArgs']]):
        pulumi.set(self, "web_server", value)

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

    @worker.setter
    def worker(self, value: Optional[pulumi.Input['EnvironmentConfigWorkloadsConfigWorkerArgs']]):
        pulumi.set(self, "worker", value)


@pulumi.input_type
class EnvironmentConfigWorkloadsConfigSchedulerArgs:
    def __init__(__self__, *,
                 count: Optional[pulumi.Input[int]] = None,
                 cpu: Optional[pulumi.Input[float]] = None,
                 memory_gb: Optional[pulumi.Input[float]] = None,
                 storage_gb: Optional[pulumi.Input[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[pulumi.Input[int]]:
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "count", value)

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

    @cpu.setter
    def cpu(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cpu", value)

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

    @memory_gb.setter
    def memory_gb(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "memory_gb", value)

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

    @storage_gb.setter
    def storage_gb(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "storage_gb", value)


@pulumi.input_type
class EnvironmentConfigWorkloadsConfigTriggererArgs:
    def __init__(__self__, *,
                 count: pulumi.Input[int],
                 cpu: pulumi.Input[float],
                 memory_gb: pulumi.Input[float]):
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "memory_gb", memory_gb)

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

    @count.setter
    def count(self, value: pulumi.Input[int]):
        pulumi.set(self, "count", value)

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

    @cpu.setter
    def cpu(self, value: pulumi.Input[float]):
        pulumi.set(self, "cpu", value)

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

    @memory_gb.setter
    def memory_gb(self, value: pulumi.Input[float]):
        pulumi.set(self, "memory_gb", value)


@pulumi.input_type
class EnvironmentConfigWorkloadsConfigWebServerArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[float]] = None,
                 memory_gb: Optional[pulumi.Input[float]] = None,
                 storage_gb: Optional[pulumi.Input[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[pulumi.Input[float]]:
        return pulumi.get(self, "cpu")

    @cpu.setter
    def cpu(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cpu", value)

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

    @memory_gb.setter
    def memory_gb(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "memory_gb", value)

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

    @storage_gb.setter
    def storage_gb(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "storage_gb", value)


@pulumi.input_type
class EnvironmentConfigWorkloadsConfigWorkerArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[float]] = None,
                 max_count: Optional[pulumi.Input[int]] = None,
                 memory_gb: Optional[pulumi.Input[float]] = None,
                 min_count: Optional[pulumi.Input[int]] = None,
                 storage_gb: Optional[pulumi.Input[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[pulumi.Input[float]]:
        return pulumi.get(self, "cpu")

    @cpu.setter
    def cpu(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "cpu", value)

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

    @max_count.setter
    def max_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_count", value)

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

    @memory_gb.setter
    def memory_gb(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "memory_gb", value)

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

    @min_count.setter
    def min_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_count", value)

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

    @storage_gb.setter
    def storage_gb(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "storage_gb", value)


