# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from ._enums import *

__all__ = [
    'ClusterApplicationArgs',
    'ClusterAutoScalingPolicyArgs',
    'ClusterBootstrapActionConfigArgs',
    'ClusterCloudWatchAlarmDefinitionArgs',
    'ClusterComputeLimitsArgs',
    'ClusterConfigurationArgs',
    'ClusterEbsBlockDeviceConfigArgs',
    'ClusterEbsConfigurationArgs',
    'ClusterHadoopJarStepConfigArgs',
    'ClusterInstanceFleetConfigArgs',
    'ClusterInstanceFleetProvisioningSpecificationsArgs',
    'ClusterInstanceGroupConfigArgs',
    'ClusterInstanceTypeConfigArgs',
    'ClusterJobFlowInstancesConfigArgs',
    'ClusterKerberosAttributesArgs',
    'ClusterKeyValueArgs',
    'ClusterManagedScalingPolicyArgs',
    'ClusterMetricDimensionArgs',
    'ClusterOnDemandProvisioningSpecificationArgs',
    'ClusterPlacementTypeArgs',
    'ClusterScalingActionArgs',
    'ClusterScalingConstraintsArgs',
    'ClusterScalingRuleArgs',
    'ClusterScalingTriggerArgs',
    'ClusterScriptBootstrapActionConfigArgs',
    'ClusterSimpleScalingPolicyConfigurationArgs',
    'ClusterSpotProvisioningSpecificationArgs',
    'ClusterStepConfigArgs',
    'ClusterTagArgs',
    'ClusterVolumeSpecificationArgs',
    'InstanceFleetConfigConfigurationArgs',
    'InstanceFleetConfigEbsBlockDeviceConfigArgs',
    'InstanceFleetConfigEbsConfigurationArgs',
    'InstanceFleetConfigInstanceFleetProvisioningSpecificationsArgs',
    'InstanceFleetConfigInstanceTypeConfigArgs',
    'InstanceFleetConfigOnDemandProvisioningSpecificationArgs',
    'InstanceFleetConfigSpotProvisioningSpecificationArgs',
    'InstanceFleetConfigVolumeSpecificationArgs',
    'InstanceGroupConfigAutoScalingPolicyArgs',
    'InstanceGroupConfigCloudWatchAlarmDefinitionArgs',
    'InstanceGroupConfigConfigurationArgs',
    'InstanceGroupConfigEbsBlockDeviceConfigArgs',
    'InstanceGroupConfigEbsConfigurationArgs',
    'InstanceGroupConfigMetricDimensionArgs',
    'InstanceGroupConfigScalingActionArgs',
    'InstanceGroupConfigScalingConstraintsArgs',
    'InstanceGroupConfigScalingRuleArgs',
    'InstanceGroupConfigScalingTriggerArgs',
    'InstanceGroupConfigSimpleScalingPolicyConfigurationArgs',
    'InstanceGroupConfigVolumeSpecificationArgs',
    'StepHadoopJarStepConfigArgs',
    'StepKeyValueArgs',
    'StudioTagArgs',
]

@pulumi.input_type
class ClusterApplicationArgs:
    def __init__(__self__, *,
                 additional_info: Optional[Any] = None,
                 args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 version: Optional[pulumi.Input[str]] = None):
        if additional_info is not None:
            pulumi.set(__self__, "additional_info", additional_info)
        if args is not None:
            pulumi.set(__self__, "args", args)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter(name="additionalInfo")
    def additional_info(self) -> Optional[Any]:
        return pulumi.get(self, "additional_info")

    @additional_info.setter
    def additional_info(self, value: Optional[Any]):
        pulumi.set(self, "additional_info", value)

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

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

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

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

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

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


@pulumi.input_type
class ClusterAutoScalingPolicyArgs:
    def __init__(__self__, *,
                 constraints: pulumi.Input['ClusterScalingConstraintsArgs'],
                 rules: pulumi.Input[Sequence[pulumi.Input['ClusterScalingRuleArgs']]]):
        pulumi.set(__self__, "constraints", constraints)
        pulumi.set(__self__, "rules", rules)

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

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

    @property
    @pulumi.getter
    def rules(self) -> pulumi.Input[Sequence[pulumi.Input['ClusterScalingRuleArgs']]]:
        return pulumi.get(self, "rules")

    @rules.setter
    def rules(self, value: pulumi.Input[Sequence[pulumi.Input['ClusterScalingRuleArgs']]]):
        pulumi.set(self, "rules", value)


@pulumi.input_type
class ClusterBootstrapActionConfigArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 script_bootstrap_action: pulumi.Input['ClusterScriptBootstrapActionConfigArgs']):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "script_bootstrap_action", script_bootstrap_action)

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

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

    @property
    @pulumi.getter(name="scriptBootstrapAction")
    def script_bootstrap_action(self) -> pulumi.Input['ClusterScriptBootstrapActionConfigArgs']:
        return pulumi.get(self, "script_bootstrap_action")

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


@pulumi.input_type
class ClusterCloudWatchAlarmDefinitionArgs:
    def __init__(__self__, *,
                 comparison_operator: pulumi.Input[str],
                 metric_name: pulumi.Input[str],
                 period: pulumi.Input[int],
                 threshold: pulumi.Input[float],
                 dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterMetricDimensionArgs']]]] = None,
                 evaluation_periods: Optional[pulumi.Input[int]] = None,
                 namespace: Optional[pulumi.Input[str]] = None,
                 statistic: Optional[pulumi.Input[str]] = None,
                 unit: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "comparison_operator", comparison_operator)
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "period", period)
        pulumi.set(__self__, "threshold", threshold)
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if evaluation_periods is not None:
            pulumi.set(__self__, "evaluation_periods", evaluation_periods)
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)
        if statistic is not None:
            pulumi.set(__self__, "statistic", statistic)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterComputeLimitsArgs:
    def __init__(__self__, *,
                 maximum_capacity_units: pulumi.Input[int],
                 minimum_capacity_units: pulumi.Input[int],
                 unit_type: pulumi.Input[str],
                 maximum_core_capacity_units: Optional[pulumi.Input[int]] = None,
                 maximum_on_demand_capacity_units: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "maximum_capacity_units", maximum_capacity_units)
        pulumi.set(__self__, "minimum_capacity_units", minimum_capacity_units)
        pulumi.set(__self__, "unit_type", unit_type)
        if maximum_core_capacity_units is not None:
            pulumi.set(__self__, "maximum_core_capacity_units", maximum_core_capacity_units)
        if maximum_on_demand_capacity_units is not None:
            pulumi.set(__self__, "maximum_on_demand_capacity_units", maximum_on_demand_capacity_units)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterConfigurationArgs:
    def __init__(__self__, *,
                 classification: Optional[pulumi.Input[str]] = None,
                 configuration_properties: Optional[Any] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterConfigurationArgs']]]] = None):
        if classification is not None:
            pulumi.set(__self__, "classification", classification)
        if configuration_properties is not None:
            pulumi.set(__self__, "configuration_properties", configuration_properties)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)

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

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

    @property
    @pulumi.getter(name="configurationProperties")
    def configuration_properties(self) -> Optional[Any]:
        return pulumi.get(self, "configuration_properties")

    @configuration_properties.setter
    def configuration_properties(self, value: Optional[Any]):
        pulumi.set(self, "configuration_properties", value)

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

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


@pulumi.input_type
class ClusterEbsBlockDeviceConfigArgs:
    def __init__(__self__, *,
                 volume_specification: pulumi.Input['ClusterVolumeSpecificationArgs'],
                 volumes_per_instance: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "volume_specification", volume_specification)
        if volumes_per_instance is not None:
            pulumi.set(__self__, "volumes_per_instance", volumes_per_instance)

    @property
    @pulumi.getter(name="volumeSpecification")
    def volume_specification(self) -> pulumi.Input['ClusterVolumeSpecificationArgs']:
        return pulumi.get(self, "volume_specification")

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

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

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


@pulumi.input_type
class ClusterEbsConfigurationArgs:
    def __init__(__self__, *,
                 ebs_block_device_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterEbsBlockDeviceConfigArgs']]]] = None,
                 ebs_optimized: Optional[pulumi.Input[bool]] = None):
        if ebs_block_device_configs is not None:
            pulumi.set(__self__, "ebs_block_device_configs", ebs_block_device_configs)
        if ebs_optimized is not None:
            pulumi.set(__self__, "ebs_optimized", ebs_optimized)

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

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

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

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


@pulumi.input_type
class ClusterHadoopJarStepConfigArgs:
    def __init__(__self__, *,
                 jar: pulumi.Input[str],
                 args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 main_class: Optional[pulumi.Input[str]] = None,
                 step_properties: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterKeyValueArgs']]]] = None):
        pulumi.set(__self__, "jar", jar)
        if args is not None:
            pulumi.set(__self__, "args", args)
        if main_class is not None:
            pulumi.set(__self__, "main_class", main_class)
        if step_properties is not None:
            pulumi.set(__self__, "step_properties", step_properties)

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterInstanceFleetConfigArgs:
    def __init__(__self__, *,
                 instance_type_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterInstanceTypeConfigArgs']]]] = None,
                 launch_specifications: Optional[pulumi.Input['ClusterInstanceFleetProvisioningSpecificationsArgs']] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 target_on_demand_capacity: Optional[pulumi.Input[int]] = None,
                 target_spot_capacity: Optional[pulumi.Input[int]] = None):
        if instance_type_configs is not None:
            pulumi.set(__self__, "instance_type_configs", instance_type_configs)
        if launch_specifications is not None:
            pulumi.set(__self__, "launch_specifications", launch_specifications)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if target_on_demand_capacity is not None:
            pulumi.set(__self__, "target_on_demand_capacity", target_on_demand_capacity)
        if target_spot_capacity is not None:
            pulumi.set(__self__, "target_spot_capacity", target_spot_capacity)

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

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

    @property
    @pulumi.getter(name="launchSpecifications")
    def launch_specifications(self) -> Optional[pulumi.Input['ClusterInstanceFleetProvisioningSpecificationsArgs']]:
        return pulumi.get(self, "launch_specifications")

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterInstanceFleetProvisioningSpecificationsArgs:
    def __init__(__self__, *,
                 on_demand_specification: Optional[pulumi.Input['ClusterOnDemandProvisioningSpecificationArgs']] = None,
                 spot_specification: Optional[pulumi.Input['ClusterSpotProvisioningSpecificationArgs']] = None):
        if on_demand_specification is not None:
            pulumi.set(__self__, "on_demand_specification", on_demand_specification)
        if spot_specification is not None:
            pulumi.set(__self__, "spot_specification", spot_specification)

    @property
    @pulumi.getter(name="onDemandSpecification")
    def on_demand_specification(self) -> Optional[pulumi.Input['ClusterOnDemandProvisioningSpecificationArgs']]:
        return pulumi.get(self, "on_demand_specification")

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

    @property
    @pulumi.getter(name="spotSpecification")
    def spot_specification(self) -> Optional[pulumi.Input['ClusterSpotProvisioningSpecificationArgs']]:
        return pulumi.get(self, "spot_specification")

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


@pulumi.input_type
class ClusterInstanceGroupConfigArgs:
    def __init__(__self__, *,
                 instance_count: pulumi.Input[int],
                 instance_type: pulumi.Input[str],
                 auto_scaling_policy: Optional[pulumi.Input['ClusterAutoScalingPolicyArgs']] = None,
                 bid_price: Optional[pulumi.Input[str]] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterConfigurationArgs']]]] = None,
                 ebs_configuration: Optional[pulumi.Input['ClusterEbsConfigurationArgs']] = None,
                 market: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "instance_count", instance_count)
        pulumi.set(__self__, "instance_type", instance_type)
        if auto_scaling_policy is not None:
            pulumi.set(__self__, "auto_scaling_policy", auto_scaling_policy)
        if bid_price is not None:
            pulumi.set(__self__, "bid_price", bid_price)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if ebs_configuration is not None:
            pulumi.set(__self__, "ebs_configuration", ebs_configuration)
        if market is not None:
            pulumi.set(__self__, "market", market)
        if name is not None:
            pulumi.set(__self__, "name", name)

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

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

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

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

    @property
    @pulumi.getter(name="autoScalingPolicy")
    def auto_scaling_policy(self) -> Optional[pulumi.Input['ClusterAutoScalingPolicyArgs']]:
        return pulumi.get(self, "auto_scaling_policy")

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

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

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

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

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

    @property
    @pulumi.getter(name="ebsConfiguration")
    def ebs_configuration(self) -> Optional[pulumi.Input['ClusterEbsConfigurationArgs']]:
        return pulumi.get(self, "ebs_configuration")

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

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

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

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

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


@pulumi.input_type
class ClusterInstanceTypeConfigArgs:
    def __init__(__self__, *,
                 instance_type: pulumi.Input[str],
                 bid_price: Optional[pulumi.Input[str]] = None,
                 bid_price_as_percentage_of_on_demand_price: Optional[pulumi.Input[float]] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterConfigurationArgs']]]] = None,
                 ebs_configuration: Optional[pulumi.Input['ClusterEbsConfigurationArgs']] = None,
                 weighted_capacity: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "instance_type", instance_type)
        if bid_price is not None:
            pulumi.set(__self__, "bid_price", bid_price)
        if bid_price_as_percentage_of_on_demand_price is not None:
            pulumi.set(__self__, "bid_price_as_percentage_of_on_demand_price", bid_price_as_percentage_of_on_demand_price)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if ebs_configuration is not None:
            pulumi.set(__self__, "ebs_configuration", ebs_configuration)
        if weighted_capacity is not None:
            pulumi.set(__self__, "weighted_capacity", weighted_capacity)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="ebsConfiguration")
    def ebs_configuration(self) -> Optional[pulumi.Input['ClusterEbsConfigurationArgs']]:
        return pulumi.get(self, "ebs_configuration")

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

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

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


@pulumi.input_type
class ClusterJobFlowInstancesConfigArgs:
    def __init__(__self__, *,
                 additional_master_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 additional_slave_security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 core_instance_fleet: Optional[pulumi.Input['ClusterInstanceFleetConfigArgs']] = None,
                 core_instance_group: Optional[pulumi.Input['ClusterInstanceGroupConfigArgs']] = None,
                 ec2_key_name: Optional[pulumi.Input[str]] = None,
                 ec2_subnet_id: Optional[pulumi.Input[str]] = None,
                 ec2_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 emr_managed_master_security_group: Optional[pulumi.Input[str]] = None,
                 emr_managed_slave_security_group: Optional[pulumi.Input[str]] = None,
                 hadoop_version: Optional[pulumi.Input[str]] = None,
                 keep_job_flow_alive_when_no_steps: Optional[pulumi.Input[bool]] = None,
                 master_instance_fleet: Optional[pulumi.Input['ClusterInstanceFleetConfigArgs']] = None,
                 master_instance_group: Optional[pulumi.Input['ClusterInstanceGroupConfigArgs']] = None,
                 placement: Optional[pulumi.Input['ClusterPlacementTypeArgs']] = None,
                 service_access_security_group: Optional[pulumi.Input[str]] = None,
                 termination_protected: Optional[pulumi.Input[bool]] = None):
        if additional_master_security_groups is not None:
            pulumi.set(__self__, "additional_master_security_groups", additional_master_security_groups)
        if additional_slave_security_groups is not None:
            pulumi.set(__self__, "additional_slave_security_groups", additional_slave_security_groups)
        if core_instance_fleet is not None:
            pulumi.set(__self__, "core_instance_fleet", core_instance_fleet)
        if core_instance_group is not None:
            pulumi.set(__self__, "core_instance_group", core_instance_group)
        if ec2_key_name is not None:
            pulumi.set(__self__, "ec2_key_name", ec2_key_name)
        if ec2_subnet_id is not None:
            pulumi.set(__self__, "ec2_subnet_id", ec2_subnet_id)
        if ec2_subnet_ids is not None:
            pulumi.set(__self__, "ec2_subnet_ids", ec2_subnet_ids)
        if emr_managed_master_security_group is not None:
            pulumi.set(__self__, "emr_managed_master_security_group", emr_managed_master_security_group)
        if emr_managed_slave_security_group is not None:
            pulumi.set(__self__, "emr_managed_slave_security_group", emr_managed_slave_security_group)
        if hadoop_version is not None:
            pulumi.set(__self__, "hadoop_version", hadoop_version)
        if keep_job_flow_alive_when_no_steps is not None:
            pulumi.set(__self__, "keep_job_flow_alive_when_no_steps", keep_job_flow_alive_when_no_steps)
        if master_instance_fleet is not None:
            pulumi.set(__self__, "master_instance_fleet", master_instance_fleet)
        if master_instance_group is not None:
            pulumi.set(__self__, "master_instance_group", master_instance_group)
        if placement is not None:
            pulumi.set(__self__, "placement", placement)
        if service_access_security_group is not None:
            pulumi.set(__self__, "service_access_security_group", service_access_security_group)
        if termination_protected is not None:
            pulumi.set(__self__, "termination_protected", termination_protected)

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

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

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

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

    @property
    @pulumi.getter(name="coreInstanceFleet")
    def core_instance_fleet(self) -> Optional[pulumi.Input['ClusterInstanceFleetConfigArgs']]:
        return pulumi.get(self, "core_instance_fleet")

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

    @property
    @pulumi.getter(name="coreInstanceGroup")
    def core_instance_group(self) -> Optional[pulumi.Input['ClusterInstanceGroupConfigArgs']]:
        return pulumi.get(self, "core_instance_group")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="masterInstanceFleet")
    def master_instance_fleet(self) -> Optional[pulumi.Input['ClusterInstanceFleetConfigArgs']]:
        return pulumi.get(self, "master_instance_fleet")

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

    @property
    @pulumi.getter(name="masterInstanceGroup")
    def master_instance_group(self) -> Optional[pulumi.Input['ClusterInstanceGroupConfigArgs']]:
        return pulumi.get(self, "master_instance_group")

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterKerberosAttributesArgs:
    def __init__(__self__, *,
                 kdc_admin_password: pulumi.Input[str],
                 realm: pulumi.Input[str],
                 a_d_domain_join_password: Optional[pulumi.Input[str]] = None,
                 a_d_domain_join_user: Optional[pulumi.Input[str]] = None,
                 cross_realm_trust_principal_password: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "kdc_admin_password", kdc_admin_password)
        pulumi.set(__self__, "realm", realm)
        if a_d_domain_join_password is not None:
            pulumi.set(__self__, "a_d_domain_join_password", a_d_domain_join_password)
        if a_d_domain_join_user is not None:
            pulumi.set(__self__, "a_d_domain_join_user", a_d_domain_join_user)
        if cross_realm_trust_principal_password is not None:
            pulumi.set(__self__, "cross_realm_trust_principal_password", cross_realm_trust_principal_password)

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


@pulumi.input_type
class ClusterManagedScalingPolicyArgs:
    def __init__(__self__, *,
                 compute_limits: Optional[pulumi.Input['ClusterComputeLimitsArgs']] = None):
        if compute_limits is not None:
            pulumi.set(__self__, "compute_limits", compute_limits)

    @property
    @pulumi.getter(name="computeLimits")
    def compute_limits(self) -> Optional[pulumi.Input['ClusterComputeLimitsArgs']]:
        return pulumi.get(self, "compute_limits")

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


@pulumi.input_type
class ClusterMetricDimensionArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

    @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)


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

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

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


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

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

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


@pulumi.input_type
class ClusterScalingActionArgs:
    def __init__(__self__, *,
                 simple_scaling_policy_configuration: pulumi.Input['ClusterSimpleScalingPolicyConfigurationArgs'],
                 market: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "simple_scaling_policy_configuration", simple_scaling_policy_configuration)
        if market is not None:
            pulumi.set(__self__, "market", market)

    @property
    @pulumi.getter(name="simpleScalingPolicyConfiguration")
    def simple_scaling_policy_configuration(self) -> pulumi.Input['ClusterSimpleScalingPolicyConfigurationArgs']:
        return pulumi.get(self, "simple_scaling_policy_configuration")

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

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

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


@pulumi.input_type
class ClusterScalingConstraintsArgs:
    def __init__(__self__, *,
                 max_capacity: pulumi.Input[int],
                 min_capacity: pulumi.Input[int]):
        pulumi.set(__self__, "max_capacity", max_capacity)
        pulumi.set(__self__, "min_capacity", min_capacity)

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

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

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

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


@pulumi.input_type
class ClusterScalingRuleArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['ClusterScalingActionArgs'],
                 name: pulumi.Input[str],
                 trigger: pulumi.Input['ClusterScalingTriggerArgs'],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "trigger", trigger)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

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

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

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

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

    @trigger.setter
    def trigger(self, value: pulumi.Input['ClusterScalingTriggerArgs']):
        pulumi.set(self, "trigger", 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 ClusterScalingTriggerArgs:
    def __init__(__self__, *,
                 cloud_watch_alarm_definition: pulumi.Input['ClusterCloudWatchAlarmDefinitionArgs']):
        pulumi.set(__self__, "cloud_watch_alarm_definition", cloud_watch_alarm_definition)

    @property
    @pulumi.getter(name="cloudWatchAlarmDefinition")
    def cloud_watch_alarm_definition(self) -> pulumi.Input['ClusterCloudWatchAlarmDefinitionArgs']:
        return pulumi.get(self, "cloud_watch_alarm_definition")

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


@pulumi.input_type
class ClusterScriptBootstrapActionConfigArgs:
    def __init__(__self__, *,
                 path: pulumi.Input[str],
                 args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "path", path)
        if args is not None:
            pulumi.set(__self__, "args", args)

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

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

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

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


@pulumi.input_type
class ClusterSimpleScalingPolicyConfigurationArgs:
    def __init__(__self__, *,
                 scaling_adjustment: pulumi.Input[int],
                 adjustment_type: Optional[pulumi.Input[str]] = None,
                 cool_down: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "scaling_adjustment", scaling_adjustment)
        if adjustment_type is not None:
            pulumi.set(__self__, "adjustment_type", adjustment_type)
        if cool_down is not None:
            pulumi.set(__self__, "cool_down", cool_down)

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

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

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

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

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

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


@pulumi.input_type
class ClusterSpotProvisioningSpecificationArgs:
    def __init__(__self__, *,
                 timeout_action: pulumi.Input[str],
                 timeout_duration_minutes: pulumi.Input[int],
                 allocation_strategy: Optional[pulumi.Input[str]] = None,
                 block_duration_minutes: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "timeout_action", timeout_action)
        pulumi.set(__self__, "timeout_duration_minutes", timeout_duration_minutes)
        if allocation_strategy is not None:
            pulumi.set(__self__, "allocation_strategy", allocation_strategy)
        if block_duration_minutes is not None:
            pulumi.set(__self__, "block_duration_minutes", block_duration_minutes)

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

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

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

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

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

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

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

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


@pulumi.input_type
class ClusterStepConfigArgs:
    def __init__(__self__, *,
                 hadoop_jar_step: pulumi.Input['ClusterHadoopJarStepConfigArgs'],
                 name: pulumi.Input[str],
                 action_on_failure: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "hadoop_jar_step", hadoop_jar_step)
        pulumi.set(__self__, "name", name)
        if action_on_failure is not None:
            pulumi.set(__self__, "action_on_failure", action_on_failure)

    @property
    @pulumi.getter(name="hadoopJarStep")
    def hadoop_jar_step(self) -> pulumi.Input['ClusterHadoopJarStepConfigArgs']:
        return pulumi.get(self, "hadoop_jar_step")

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

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

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

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

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


@pulumi.input_type
class ClusterTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

    @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)


@pulumi.input_type
class ClusterVolumeSpecificationArgs:
    def __init__(__self__, *,
                 size_in_gb: pulumi.Input[int],
                 volume_type: pulumi.Input[str],
                 iops: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "size_in_gb", size_in_gb)
        pulumi.set(__self__, "volume_type", volume_type)
        if iops is not None:
            pulumi.set(__self__, "iops", iops)

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

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

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

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

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

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


@pulumi.input_type
class InstanceFleetConfigConfigurationArgs:
    def __init__(__self__, *,
                 classification: Optional[pulumi.Input[str]] = None,
                 configuration_properties: Optional[Any] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFleetConfigConfigurationArgs']]]] = None):
        if classification is not None:
            pulumi.set(__self__, "classification", classification)
        if configuration_properties is not None:
            pulumi.set(__self__, "configuration_properties", configuration_properties)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)

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

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

    @property
    @pulumi.getter(name="configurationProperties")
    def configuration_properties(self) -> Optional[Any]:
        return pulumi.get(self, "configuration_properties")

    @configuration_properties.setter
    def configuration_properties(self, value: Optional[Any]):
        pulumi.set(self, "configuration_properties", value)

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

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


@pulumi.input_type
class InstanceFleetConfigEbsBlockDeviceConfigArgs:
    def __init__(__self__, *,
                 volume_specification: pulumi.Input['InstanceFleetConfigVolumeSpecificationArgs'],
                 volumes_per_instance: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "volume_specification", volume_specification)
        if volumes_per_instance is not None:
            pulumi.set(__self__, "volumes_per_instance", volumes_per_instance)

    @property
    @pulumi.getter(name="volumeSpecification")
    def volume_specification(self) -> pulumi.Input['InstanceFleetConfigVolumeSpecificationArgs']:
        return pulumi.get(self, "volume_specification")

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

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

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


@pulumi.input_type
class InstanceFleetConfigEbsConfigurationArgs:
    def __init__(__self__, *,
                 ebs_block_device_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFleetConfigEbsBlockDeviceConfigArgs']]]] = None,
                 ebs_optimized: Optional[pulumi.Input[bool]] = None):
        if ebs_block_device_configs is not None:
            pulumi.set(__self__, "ebs_block_device_configs", ebs_block_device_configs)
        if ebs_optimized is not None:
            pulumi.set(__self__, "ebs_optimized", ebs_optimized)

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

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

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

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


@pulumi.input_type
class InstanceFleetConfigInstanceFleetProvisioningSpecificationsArgs:
    def __init__(__self__, *,
                 on_demand_specification: Optional[pulumi.Input['InstanceFleetConfigOnDemandProvisioningSpecificationArgs']] = None,
                 spot_specification: Optional[pulumi.Input['InstanceFleetConfigSpotProvisioningSpecificationArgs']] = None):
        if on_demand_specification is not None:
            pulumi.set(__self__, "on_demand_specification", on_demand_specification)
        if spot_specification is not None:
            pulumi.set(__self__, "spot_specification", spot_specification)

    @property
    @pulumi.getter(name="onDemandSpecification")
    def on_demand_specification(self) -> Optional[pulumi.Input['InstanceFleetConfigOnDemandProvisioningSpecificationArgs']]:
        return pulumi.get(self, "on_demand_specification")

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

    @property
    @pulumi.getter(name="spotSpecification")
    def spot_specification(self) -> Optional[pulumi.Input['InstanceFleetConfigSpotProvisioningSpecificationArgs']]:
        return pulumi.get(self, "spot_specification")

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


@pulumi.input_type
class InstanceFleetConfigInstanceTypeConfigArgs:
    def __init__(__self__, *,
                 instance_type: pulumi.Input[str],
                 bid_price: Optional[pulumi.Input[str]] = None,
                 bid_price_as_percentage_of_on_demand_price: Optional[pulumi.Input[float]] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceFleetConfigConfigurationArgs']]]] = None,
                 ebs_configuration: Optional[pulumi.Input['InstanceFleetConfigEbsConfigurationArgs']] = None,
                 weighted_capacity: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "instance_type", instance_type)
        if bid_price is not None:
            pulumi.set(__self__, "bid_price", bid_price)
        if bid_price_as_percentage_of_on_demand_price is not None:
            pulumi.set(__self__, "bid_price_as_percentage_of_on_demand_price", bid_price_as_percentage_of_on_demand_price)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)
        if ebs_configuration is not None:
            pulumi.set(__self__, "ebs_configuration", ebs_configuration)
        if weighted_capacity is not None:
            pulumi.set(__self__, "weighted_capacity", weighted_capacity)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="ebsConfiguration")
    def ebs_configuration(self) -> Optional[pulumi.Input['InstanceFleetConfigEbsConfigurationArgs']]:
        return pulumi.get(self, "ebs_configuration")

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

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

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


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

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

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


@pulumi.input_type
class InstanceFleetConfigSpotProvisioningSpecificationArgs:
    def __init__(__self__, *,
                 timeout_action: pulumi.Input[str],
                 timeout_duration_minutes: pulumi.Input[int],
                 allocation_strategy: Optional[pulumi.Input[str]] = None,
                 block_duration_minutes: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "timeout_action", timeout_action)
        pulumi.set(__self__, "timeout_duration_minutes", timeout_duration_minutes)
        if allocation_strategy is not None:
            pulumi.set(__self__, "allocation_strategy", allocation_strategy)
        if block_duration_minutes is not None:
            pulumi.set(__self__, "block_duration_minutes", block_duration_minutes)

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

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

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

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

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

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

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

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


@pulumi.input_type
class InstanceFleetConfigVolumeSpecificationArgs:
    def __init__(__self__, *,
                 size_in_gb: pulumi.Input[int],
                 volume_type: pulumi.Input[str],
                 iops: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "size_in_gb", size_in_gb)
        pulumi.set(__self__, "volume_type", volume_type)
        if iops is not None:
            pulumi.set(__self__, "iops", iops)

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

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

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

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

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

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


@pulumi.input_type
class InstanceGroupConfigAutoScalingPolicyArgs:
    def __init__(__self__, *,
                 constraints: pulumi.Input['InstanceGroupConfigScalingConstraintsArgs'],
                 rules: pulumi.Input[Sequence[pulumi.Input['InstanceGroupConfigScalingRuleArgs']]]):
        pulumi.set(__self__, "constraints", constraints)
        pulumi.set(__self__, "rules", rules)

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

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

    @property
    @pulumi.getter
    def rules(self) -> pulumi.Input[Sequence[pulumi.Input['InstanceGroupConfigScalingRuleArgs']]]:
        return pulumi.get(self, "rules")

    @rules.setter
    def rules(self, value: pulumi.Input[Sequence[pulumi.Input['InstanceGroupConfigScalingRuleArgs']]]):
        pulumi.set(self, "rules", value)


@pulumi.input_type
class InstanceGroupConfigCloudWatchAlarmDefinitionArgs:
    def __init__(__self__, *,
                 comparison_operator: pulumi.Input[str],
                 metric_name: pulumi.Input[str],
                 period: pulumi.Input[int],
                 threshold: pulumi.Input[float],
                 dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupConfigMetricDimensionArgs']]]] = None,
                 evaluation_periods: Optional[pulumi.Input[int]] = None,
                 namespace: Optional[pulumi.Input[str]] = None,
                 statistic: Optional[pulumi.Input[str]] = None,
                 unit: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "comparison_operator", comparison_operator)
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "period", period)
        pulumi.set(__self__, "threshold", threshold)
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if evaluation_periods is not None:
            pulumi.set(__self__, "evaluation_periods", evaluation_periods)
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)
        if statistic is not None:
            pulumi.set(__self__, "statistic", statistic)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class InstanceGroupConfigConfigurationArgs:
    def __init__(__self__, *,
                 classification: Optional[pulumi.Input[str]] = None,
                 configuration_properties: Optional[Any] = None,
                 configurations: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupConfigConfigurationArgs']]]] = None):
        if classification is not None:
            pulumi.set(__self__, "classification", classification)
        if configuration_properties is not None:
            pulumi.set(__self__, "configuration_properties", configuration_properties)
        if configurations is not None:
            pulumi.set(__self__, "configurations", configurations)

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

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

    @property
    @pulumi.getter(name="configurationProperties")
    def configuration_properties(self) -> Optional[Any]:
        return pulumi.get(self, "configuration_properties")

    @configuration_properties.setter
    def configuration_properties(self, value: Optional[Any]):
        pulumi.set(self, "configuration_properties", value)

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

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


@pulumi.input_type
class InstanceGroupConfigEbsBlockDeviceConfigArgs:
    def __init__(__self__, *,
                 volume_specification: pulumi.Input['InstanceGroupConfigVolumeSpecificationArgs'],
                 volumes_per_instance: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "volume_specification", volume_specification)
        if volumes_per_instance is not None:
            pulumi.set(__self__, "volumes_per_instance", volumes_per_instance)

    @property
    @pulumi.getter(name="volumeSpecification")
    def volume_specification(self) -> pulumi.Input['InstanceGroupConfigVolumeSpecificationArgs']:
        return pulumi.get(self, "volume_specification")

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

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

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


@pulumi.input_type
class InstanceGroupConfigEbsConfigurationArgs:
    def __init__(__self__, *,
                 ebs_block_device_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceGroupConfigEbsBlockDeviceConfigArgs']]]] = None,
                 ebs_optimized: Optional[pulumi.Input[bool]] = None):
        if ebs_block_device_configs is not None:
            pulumi.set(__self__, "ebs_block_device_configs", ebs_block_device_configs)
        if ebs_optimized is not None:
            pulumi.set(__self__, "ebs_optimized", ebs_optimized)

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

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

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

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


@pulumi.input_type
class InstanceGroupConfigMetricDimensionArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

    @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)


@pulumi.input_type
class InstanceGroupConfigScalingActionArgs:
    def __init__(__self__, *,
                 simple_scaling_policy_configuration: pulumi.Input['InstanceGroupConfigSimpleScalingPolicyConfigurationArgs'],
                 market: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "simple_scaling_policy_configuration", simple_scaling_policy_configuration)
        if market is not None:
            pulumi.set(__self__, "market", market)

    @property
    @pulumi.getter(name="simpleScalingPolicyConfiguration")
    def simple_scaling_policy_configuration(self) -> pulumi.Input['InstanceGroupConfigSimpleScalingPolicyConfigurationArgs']:
        return pulumi.get(self, "simple_scaling_policy_configuration")

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

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

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


@pulumi.input_type
class InstanceGroupConfigScalingConstraintsArgs:
    def __init__(__self__, *,
                 max_capacity: pulumi.Input[int],
                 min_capacity: pulumi.Input[int]):
        pulumi.set(__self__, "max_capacity", max_capacity)
        pulumi.set(__self__, "min_capacity", min_capacity)

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

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

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

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


@pulumi.input_type
class InstanceGroupConfigScalingRuleArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['InstanceGroupConfigScalingActionArgs'],
                 name: pulumi.Input[str],
                 trigger: pulumi.Input['InstanceGroupConfigScalingTriggerArgs'],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "trigger", trigger)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

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

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

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

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

    @trigger.setter
    def trigger(self, value: pulumi.Input['InstanceGroupConfigScalingTriggerArgs']):
        pulumi.set(self, "trigger", 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 InstanceGroupConfigScalingTriggerArgs:
    def __init__(__self__, *,
                 cloud_watch_alarm_definition: pulumi.Input['InstanceGroupConfigCloudWatchAlarmDefinitionArgs']):
        pulumi.set(__self__, "cloud_watch_alarm_definition", cloud_watch_alarm_definition)

    @property
    @pulumi.getter(name="cloudWatchAlarmDefinition")
    def cloud_watch_alarm_definition(self) -> pulumi.Input['InstanceGroupConfigCloudWatchAlarmDefinitionArgs']:
        return pulumi.get(self, "cloud_watch_alarm_definition")

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


@pulumi.input_type
class InstanceGroupConfigSimpleScalingPolicyConfigurationArgs:
    def __init__(__self__, *,
                 scaling_adjustment: pulumi.Input[int],
                 adjustment_type: Optional[pulumi.Input[str]] = None,
                 cool_down: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "scaling_adjustment", scaling_adjustment)
        if adjustment_type is not None:
            pulumi.set(__self__, "adjustment_type", adjustment_type)
        if cool_down is not None:
            pulumi.set(__self__, "cool_down", cool_down)

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

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

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

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

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

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


@pulumi.input_type
class InstanceGroupConfigVolumeSpecificationArgs:
    def __init__(__self__, *,
                 size_in_gb: pulumi.Input[int],
                 volume_type: pulumi.Input[str],
                 iops: Optional[pulumi.Input[int]] = None):
        pulumi.set(__self__, "size_in_gb", size_in_gb)
        pulumi.set(__self__, "volume_type", volume_type)
        if iops is not None:
            pulumi.set(__self__, "iops", iops)

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

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

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

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

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

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


@pulumi.input_type
class StepHadoopJarStepConfigArgs:
    def __init__(__self__, *,
                 jar: pulumi.Input[str],
                 args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 main_class: Optional[pulumi.Input[str]] = None,
                 step_properties: Optional[pulumi.Input[Sequence[pulumi.Input['StepKeyValueArgs']]]] = None):
        pulumi.set(__self__, "jar", jar)
        if args is not None:
            pulumi.set(__self__, "args", args)
        if main_class is not None:
            pulumi.set(__self__, "main_class", main_class)
        if step_properties is not None:
            pulumi.set(__self__, "step_properties", step_properties)

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

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

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

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

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

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

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

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


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

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

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

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

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


@pulumi.input_type
class StudioTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        An arbitrary set of tags (key-value pairs) for this EMR Studio.
        :param pulumi.Input[str] key: The key name of the tag. You can specify a value that is 1 to 127 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. 
        :param pulumi.Input[str] value: The value for the tag. You can specify a value that is 0 to 255 Unicode characters in length. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. 
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        The key name of the tag. You can specify a value that is 1 to 127 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. 
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The value for the tag. You can specify a value that is 0 to 255 Unicode characters in length. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. 
        """
        return pulumi.get(self, "value")

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


