# 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 . import outputs

__all__ = [
    'ComputeEnvironmentComputeResources',
    'ComputeEnvironmentEc2ConfigurationObject',
    'ComputeEnvironmentLaunchTemplateSpecification',
    'JobDefinitionAuthorizationConfig',
    'JobDefinitionContainerProperties',
    'JobDefinitionDevice',
    'JobDefinitionEfsVolumeConfiguration',
    'JobDefinitionEnvironment',
    'JobDefinitionEvaluateOnExit',
    'JobDefinitionFargatePlatformConfiguration',
    'JobDefinitionLinuxParameters',
    'JobDefinitionLogConfiguration',
    'JobDefinitionMountPoints',
    'JobDefinitionNetworkConfiguration',
    'JobDefinitionNodeProperties',
    'JobDefinitionNodeRangeProperty',
    'JobDefinitionResourceRequirement',
    'JobDefinitionRetryStrategy',
    'JobDefinitionSecret',
    'JobDefinitionTimeout',
    'JobDefinitionTmpfs',
    'JobDefinitionUlimit',
    'JobDefinitionVolumes',
    'JobDefinitionVolumesHost',
    'JobQueueComputeEnvironmentOrder',
]

@pulumi.output_type
class ComputeEnvironmentComputeResources(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxvCpus":
            suggest = "maxv_cpus"
        elif key == "allocationStrategy":
            suggest = "allocation_strategy"
        elif key == "bidPercentage":
            suggest = "bid_percentage"
        elif key == "desiredvCpus":
            suggest = "desiredv_cpus"
        elif key == "ec2Configuration":
            suggest = "ec2_configuration"
        elif key == "ec2KeyPair":
            suggest = "ec2_key_pair"
        elif key == "imageId":
            suggest = "image_id"
        elif key == "instanceRole":
            suggest = "instance_role"
        elif key == "instanceTypes":
            suggest = "instance_types"
        elif key == "launchTemplate":
            suggest = "launch_template"
        elif key == "minvCpus":
            suggest = "minv_cpus"
        elif key == "placementGroup":
            suggest = "placement_group"
        elif key == "securityGroupIds":
            suggest = "security_group_ids"
        elif key == "spotIamFleetRole":
            suggest = "spot_iam_fleet_role"

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

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

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

    def __init__(__self__, *,
                 maxv_cpus: int,
                 subnets: Sequence[str],
                 type: str,
                 allocation_strategy: Optional[str] = None,
                 bid_percentage: Optional[int] = None,
                 desiredv_cpus: Optional[int] = None,
                 ec2_configuration: Optional[Sequence['outputs.ComputeEnvironmentEc2ConfigurationObject']] = None,
                 ec2_key_pair: Optional[str] = None,
                 image_id: Optional[str] = None,
                 instance_role: Optional[str] = None,
                 instance_types: Optional[Sequence[str]] = None,
                 launch_template: Optional['outputs.ComputeEnvironmentLaunchTemplateSpecification'] = None,
                 minv_cpus: Optional[int] = None,
                 placement_group: Optional[str] = None,
                 security_group_ids: Optional[Sequence[str]] = None,
                 spot_iam_fleet_role: Optional[str] = None,
                 tags: Optional[Any] = None):
        pulumi.set(__self__, "maxv_cpus", maxv_cpus)
        pulumi.set(__self__, "subnets", subnets)
        pulumi.set(__self__, "type", type)
        if allocation_strategy is not None:
            pulumi.set(__self__, "allocation_strategy", allocation_strategy)
        if bid_percentage is not None:
            pulumi.set(__self__, "bid_percentage", bid_percentage)
        if desiredv_cpus is not None:
            pulumi.set(__self__, "desiredv_cpus", desiredv_cpus)
        if ec2_configuration is not None:
            pulumi.set(__self__, "ec2_configuration", ec2_configuration)
        if ec2_key_pair is not None:
            pulumi.set(__self__, "ec2_key_pair", ec2_key_pair)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if instance_role is not None:
            pulumi.set(__self__, "instance_role", instance_role)
        if instance_types is not None:
            pulumi.set(__self__, "instance_types", instance_types)
        if launch_template is not None:
            pulumi.set(__self__, "launch_template", launch_template)
        if minv_cpus is not None:
            pulumi.set(__self__, "minv_cpus", minv_cpus)
        if placement_group is not None:
            pulumi.set(__self__, "placement_group", placement_group)
        if security_group_ids is not None:
            pulumi.set(__self__, "security_group_ids", security_group_ids)
        if spot_iam_fleet_role is not None:
            pulumi.set(__self__, "spot_iam_fleet_role", spot_iam_fleet_role)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="launchTemplate")
    def launch_template(self) -> Optional['outputs.ComputeEnvironmentLaunchTemplateSpecification']:
        return pulumi.get(self, "launch_template")

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

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

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

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

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


@pulumi.output_type
class ComputeEnvironmentEc2ConfigurationObject(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "imageType":
            suggest = "image_type"
        elif key == "imageIdOverride":
            suggest = "image_id_override"

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

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

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

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

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

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


@pulumi.output_type
class ComputeEnvironmentLaunchTemplateSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "launchTemplateId":
            suggest = "launch_template_id"
        elif key == "launchTemplateName":
            suggest = "launch_template_name"

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

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

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

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

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

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

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


@pulumi.output_type
class JobDefinitionAuthorizationConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessPointId":
            suggest = "access_point_id"

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

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

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

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

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

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


@pulumi.output_type
class JobDefinitionContainerProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "executionRoleArn":
            suggest = "execution_role_arn"
        elif key == "fargatePlatformConfiguration":
            suggest = "fargate_platform_configuration"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "jobRoleArn":
            suggest = "job_role_arn"
        elif key == "linuxParameters":
            suggest = "linux_parameters"
        elif key == "logConfiguration":
            suggest = "log_configuration"
        elif key == "mountPoints":
            suggest = "mount_points"
        elif key == "networkConfiguration":
            suggest = "network_configuration"
        elif key == "readonlyRootFilesystem":
            suggest = "readonly_root_filesystem"
        elif key == "resourceRequirements":
            suggest = "resource_requirements"

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

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

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

    def __init__(__self__, *,
                 image: str,
                 command: Optional[Sequence[str]] = None,
                 environment: Optional[Sequence['outputs.JobDefinitionEnvironment']] = None,
                 execution_role_arn: Optional[str] = None,
                 fargate_platform_configuration: Optional['outputs.JobDefinitionFargatePlatformConfiguration'] = None,
                 instance_type: Optional[str] = None,
                 job_role_arn: Optional[str] = None,
                 linux_parameters: Optional['outputs.JobDefinitionLinuxParameters'] = None,
                 log_configuration: Optional['outputs.JobDefinitionLogConfiguration'] = None,
                 memory: Optional[int] = None,
                 mount_points: Optional[Sequence['outputs.JobDefinitionMountPoints']] = None,
                 network_configuration: Optional['outputs.JobDefinitionNetworkConfiguration'] = None,
                 privileged: Optional[bool] = None,
                 readonly_root_filesystem: Optional[bool] = None,
                 resource_requirements: Optional[Sequence['outputs.JobDefinitionResourceRequirement']] = None,
                 secrets: Optional[Sequence['outputs.JobDefinitionSecret']] = None,
                 ulimits: Optional[Sequence['outputs.JobDefinitionUlimit']] = None,
                 user: Optional[str] = None,
                 vcpus: Optional[int] = None,
                 volumes: Optional[Sequence['outputs.JobDefinitionVolumes']] = None):
        pulumi.set(__self__, "image", image)
        if command is not None:
            pulumi.set(__self__, "command", command)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)
        if execution_role_arn is not None:
            pulumi.set(__self__, "execution_role_arn", execution_role_arn)
        if fargate_platform_configuration is not None:
            pulumi.set(__self__, "fargate_platform_configuration", fargate_platform_configuration)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if job_role_arn is not None:
            pulumi.set(__self__, "job_role_arn", job_role_arn)
        if linux_parameters is not None:
            pulumi.set(__self__, "linux_parameters", linux_parameters)
        if log_configuration is not None:
            pulumi.set(__self__, "log_configuration", log_configuration)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if mount_points is not None:
            pulumi.set(__self__, "mount_points", mount_points)
        if network_configuration is not None:
            pulumi.set(__self__, "network_configuration", network_configuration)
        if privileged is not None:
            pulumi.set(__self__, "privileged", privileged)
        if readonly_root_filesystem is not None:
            pulumi.set(__self__, "readonly_root_filesystem", readonly_root_filesystem)
        if resource_requirements is not None:
            pulumi.set(__self__, "resource_requirements", resource_requirements)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if ulimits is not None:
            pulumi.set(__self__, "ulimits", ulimits)
        if user is not None:
            pulumi.set(__self__, "user", user)
        if vcpus is not None:
            pulumi.set(__self__, "vcpus", vcpus)
        if volumes is not None:
            pulumi.set(__self__, "volumes", volumes)

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

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

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

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

    @property
    @pulumi.getter(name="fargatePlatformConfiguration")
    def fargate_platform_configuration(self) -> Optional['outputs.JobDefinitionFargatePlatformConfiguration']:
        return pulumi.get(self, "fargate_platform_configuration")

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

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

    @property
    @pulumi.getter(name="linuxParameters")
    def linux_parameters(self) -> Optional['outputs.JobDefinitionLinuxParameters']:
        return pulumi.get(self, "linux_parameters")

    @property
    @pulumi.getter(name="logConfiguration")
    def log_configuration(self) -> Optional['outputs.JobDefinitionLogConfiguration']:
        return pulumi.get(self, "log_configuration")

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

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

    @property
    @pulumi.getter(name="networkConfiguration")
    def network_configuration(self) -> Optional['outputs.JobDefinitionNetworkConfiguration']:
        return pulumi.get(self, "network_configuration")

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

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

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

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

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

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

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

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


@pulumi.output_type
class JobDefinitionDevice(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "containerPath":
            suggest = "container_path"
        elif key == "hostPath":
            suggest = "host_path"

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

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

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

    def __init__(__self__, *,
                 container_path: Optional[str] = None,
                 host_path: Optional[str] = None,
                 permissions: Optional[Sequence[str]] = None):
        if container_path is not None:
            pulumi.set(__self__, "container_path", container_path)
        if host_path is not None:
            pulumi.set(__self__, "host_path", host_path)
        if permissions is not None:
            pulumi.set(__self__, "permissions", permissions)

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

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

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


@pulumi.output_type
class JobDefinitionEfsVolumeConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fileSystemId":
            suggest = "file_system_id"
        elif key == "authorizationConfig":
            suggest = "authorization_config"
        elif key == "rootDirectory":
            suggest = "root_directory"
        elif key == "transitEncryption":
            suggest = "transit_encryption"
        elif key == "transitEncryptionPort":
            suggest = "transit_encryption_port"

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

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

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

    def __init__(__self__, *,
                 file_system_id: str,
                 authorization_config: Optional['outputs.JobDefinitionAuthorizationConfig'] = None,
                 root_directory: Optional[str] = None,
                 transit_encryption: Optional[str] = None,
                 transit_encryption_port: Optional[int] = None):
        pulumi.set(__self__, "file_system_id", file_system_id)
        if authorization_config is not None:
            pulumi.set(__self__, "authorization_config", authorization_config)
        if root_directory is not None:
            pulumi.set(__self__, "root_directory", root_directory)
        if transit_encryption is not None:
            pulumi.set(__self__, "transit_encryption", transit_encryption)
        if transit_encryption_port is not None:
            pulumi.set(__self__, "transit_encryption_port", transit_encryption_port)

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

    @property
    @pulumi.getter(name="authorizationConfig")
    def authorization_config(self) -> Optional['outputs.JobDefinitionAuthorizationConfig']:
        return pulumi.get(self, "authorization_config")

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

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

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


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

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

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


@pulumi.output_type
class JobDefinitionEvaluateOnExit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "onExitCode":
            suggest = "on_exit_code"
        elif key == "onReason":
            suggest = "on_reason"
        elif key == "onStatusReason":
            suggest = "on_status_reason"

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

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

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

    def __init__(__self__, *,
                 action: str,
                 on_exit_code: Optional[str] = None,
                 on_reason: Optional[str] = None,
                 on_status_reason: Optional[str] = None):
        pulumi.set(__self__, "action", action)
        if on_exit_code is not None:
            pulumi.set(__self__, "on_exit_code", on_exit_code)
        if on_reason is not None:
            pulumi.set(__self__, "on_reason", on_reason)
        if on_status_reason is not None:
            pulumi.set(__self__, "on_status_reason", on_status_reason)

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

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

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

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


@pulumi.output_type
class JobDefinitionFargatePlatformConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "platformVersion":
            suggest = "platform_version"

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

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

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

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

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


@pulumi.output_type
class JobDefinitionLinuxParameters(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "initProcessEnabled":
            suggest = "init_process_enabled"
        elif key == "maxSwap":
            suggest = "max_swap"
        elif key == "sharedMemorySize":
            suggest = "shared_memory_size"

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

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

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

    def __init__(__self__, *,
                 devices: Optional[Sequence['outputs.JobDefinitionDevice']] = None,
                 init_process_enabled: Optional[bool] = None,
                 max_swap: Optional[int] = None,
                 shared_memory_size: Optional[int] = None,
                 swappiness: Optional[int] = None,
                 tmpfs: Optional[Sequence['outputs.JobDefinitionTmpfs']] = None):
        if devices is not None:
            pulumi.set(__self__, "devices", devices)
        if init_process_enabled is not None:
            pulumi.set(__self__, "init_process_enabled", init_process_enabled)
        if max_swap is not None:
            pulumi.set(__self__, "max_swap", max_swap)
        if shared_memory_size is not None:
            pulumi.set(__self__, "shared_memory_size", shared_memory_size)
        if swappiness is not None:
            pulumi.set(__self__, "swappiness", swappiness)
        if tmpfs is not None:
            pulumi.set(__self__, "tmpfs", tmpfs)

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

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

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

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

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

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


@pulumi.output_type
class JobDefinitionLogConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logDriver":
            suggest = "log_driver"
        elif key == "secretOptions":
            suggest = "secret_options"

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

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

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

    def __init__(__self__, *,
                 log_driver: str,
                 options: Optional[Any] = None,
                 secret_options: Optional[Sequence['outputs.JobDefinitionSecret']] = None):
        pulumi.set(__self__, "log_driver", log_driver)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if secret_options is not None:
            pulumi.set(__self__, "secret_options", secret_options)

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

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

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


@pulumi.output_type
class JobDefinitionMountPoints(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "containerPath":
            suggest = "container_path"
        elif key == "readOnly":
            suggest = "read_only"
        elif key == "sourceVolume":
            suggest = "source_volume"

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

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

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

    def __init__(__self__, *,
                 container_path: Optional[str] = None,
                 read_only: Optional[bool] = None,
                 source_volume: Optional[str] = None):
        if container_path is not None:
            pulumi.set(__self__, "container_path", container_path)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)
        if source_volume is not None:
            pulumi.set(__self__, "source_volume", source_volume)

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

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

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


@pulumi.output_type
class JobDefinitionNetworkConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "assignPublicIp":
            suggest = "assign_public_ip"

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

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

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

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

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


@pulumi.output_type
class JobDefinitionNodeProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "mainNode":
            suggest = "main_node"
        elif key == "nodeRangeProperties":
            suggest = "node_range_properties"
        elif key == "numNodes":
            suggest = "num_nodes"

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

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

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

    def __init__(__self__, *,
                 main_node: int,
                 node_range_properties: Sequence['outputs.JobDefinitionNodeRangeProperty'],
                 num_nodes: int):
        pulumi.set(__self__, "main_node", main_node)
        pulumi.set(__self__, "node_range_properties", node_range_properties)
        pulumi.set(__self__, "num_nodes", num_nodes)

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

    @property
    @pulumi.getter(name="nodeRangeProperties")
    def node_range_properties(self) -> Sequence['outputs.JobDefinitionNodeRangeProperty']:
        return pulumi.get(self, "node_range_properties")

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


@pulumi.output_type
class JobDefinitionNodeRangeProperty(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetNodes":
            suggest = "target_nodes"

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

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

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

    def __init__(__self__, *,
                 target_nodes: str,
                 container: Optional['outputs.JobDefinitionContainerProperties'] = None):
        pulumi.set(__self__, "target_nodes", target_nodes)
        if container is not None:
            pulumi.set(__self__, "container", container)

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

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


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

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

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


@pulumi.output_type
class JobDefinitionRetryStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "evaluateOnExit":
            suggest = "evaluate_on_exit"

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

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

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

    def __init__(__self__, *,
                 attempts: Optional[int] = None,
                 evaluate_on_exit: Optional[Sequence['outputs.JobDefinitionEvaluateOnExit']] = None):
        if attempts is not None:
            pulumi.set(__self__, "attempts", attempts)
        if evaluate_on_exit is not None:
            pulumi.set(__self__, "evaluate_on_exit", evaluate_on_exit)

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

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


@pulumi.output_type
class JobDefinitionSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "valueFrom":
            suggest = "value_from"

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

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

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

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

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

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


@pulumi.output_type
class JobDefinitionTimeout(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "attemptDurationSeconds":
            suggest = "attempt_duration_seconds"

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

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

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

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

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


@pulumi.output_type
class JobDefinitionTmpfs(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "containerPath":
            suggest = "container_path"
        elif key == "mountOptions":
            suggest = "mount_options"

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

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

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

    def __init__(__self__, *,
                 container_path: str,
                 size: int,
                 mount_options: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "container_path", container_path)
        pulumi.set(__self__, "size", size)
        if mount_options is not None:
            pulumi.set(__self__, "mount_options", mount_options)

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

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

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


@pulumi.output_type
class JobDefinitionUlimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hardLimit":
            suggest = "hard_limit"
        elif key == "softLimit":
            suggest = "soft_limit"

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

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

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

    def __init__(__self__, *,
                 hard_limit: int,
                 name: str,
                 soft_limit: int):
        pulumi.set(__self__, "hard_limit", hard_limit)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "soft_limit", soft_limit)

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

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

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


@pulumi.output_type
class JobDefinitionVolumes(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "efsVolumeConfiguration":
            suggest = "efs_volume_configuration"

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

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

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

    def __init__(__self__, *,
                 efs_volume_configuration: Optional['outputs.JobDefinitionEfsVolumeConfiguration'] = None,
                 host: Optional['outputs.JobDefinitionVolumesHost'] = None,
                 name: Optional[str] = None):
        if efs_volume_configuration is not None:
            pulumi.set(__self__, "efs_volume_configuration", efs_volume_configuration)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="efsVolumeConfiguration")
    def efs_volume_configuration(self) -> Optional['outputs.JobDefinitionEfsVolumeConfiguration']:
        return pulumi.get(self, "efs_volume_configuration")

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

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


@pulumi.output_type
class JobDefinitionVolumesHost(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourcePath":
            suggest = "source_path"

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

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

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

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

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


@pulumi.output_type
class JobQueueComputeEnvironmentOrder(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "computeEnvironment":
            suggest = "compute_environment"

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

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

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

    def __init__(__self__, *,
                 compute_environment: str,
                 order: int):
        pulumi.set(__self__, "compute_environment", compute_environment)
        pulumi.set(__self__, "order", order)

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

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


