# 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

__all__ = [
    'ComputeEnvironmentComputeResourcesArgs',
    'ComputeEnvironmentEc2ConfigurationObjectArgs',
    'ComputeEnvironmentLaunchTemplateSpecificationArgs',
    'JobDefinitionAuthorizationConfigArgs',
    'JobDefinitionContainerPropertiesArgs',
    'JobDefinitionDeviceArgs',
    'JobDefinitionEfsVolumeConfigurationArgs',
    'JobDefinitionEnvironmentArgs',
    'JobDefinitionEvaluateOnExitArgs',
    'JobDefinitionFargatePlatformConfigurationArgs',
    'JobDefinitionLinuxParametersArgs',
    'JobDefinitionLogConfigurationArgs',
    'JobDefinitionMountPointsArgs',
    'JobDefinitionNetworkConfigurationArgs',
    'JobDefinitionNodePropertiesArgs',
    'JobDefinitionNodeRangePropertyArgs',
    'JobDefinitionResourceRequirementArgs',
    'JobDefinitionRetryStrategyArgs',
    'JobDefinitionSecretArgs',
    'JobDefinitionTimeoutArgs',
    'JobDefinitionTmpfsArgs',
    'JobDefinitionUlimitArgs',
    'JobDefinitionVolumesHostArgs',
    'JobDefinitionVolumesArgs',
    'JobQueueComputeEnvironmentOrderArgs',
]

@pulumi.input_type
class ComputeEnvironmentComputeResourcesArgs:
    def __init__(__self__, *,
                 maxv_cpus: pulumi.Input[int],
                 subnets: pulumi.Input[Sequence[pulumi.Input[str]]],
                 type: pulumi.Input[str],
                 allocation_strategy: Optional[pulumi.Input[str]] = None,
                 bid_percentage: Optional[pulumi.Input[int]] = None,
                 desiredv_cpus: Optional[pulumi.Input[int]] = None,
                 ec2_configuration: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeEnvironmentEc2ConfigurationObjectArgs']]]] = None,
                 ec2_key_pair: Optional[pulumi.Input[str]] = None,
                 image_id: Optional[pulumi.Input[str]] = None,
                 instance_role: Optional[pulumi.Input[str]] = None,
                 instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 launch_template: Optional[pulumi.Input['ComputeEnvironmentLaunchTemplateSpecificationArgs']] = None,
                 minv_cpus: Optional[pulumi.Input[int]] = None,
                 placement_group: Optional[pulumi.Input[str]] = None,
                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 spot_iam_fleet_role: Optional[pulumi.Input[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) -> pulumi.Input[int]:
        return pulumi.get(self, "maxv_cpus")

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

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

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

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

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", 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="bidPercentage")
    def bid_percentage(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "bid_percentage")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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


@pulumi.input_type
class ComputeEnvironmentLaunchTemplateSpecificationArgs:
    def __init__(__self__, *,
                 launch_template_id: Optional[pulumi.Input[str]] = None,
                 launch_template_name: Optional[pulumi.Input[str]] = None,
                 version: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "launch_template_id")

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

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

    @launch_template_name.setter
    def launch_template_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "launch_template_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 JobDefinitionAuthorizationConfigArgs:
    def __init__(__self__, *,
                 access_point_id: Optional[pulumi.Input[str]] = None,
                 iam: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "access_point_id")

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

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

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


@pulumi.input_type
class JobDefinitionContainerPropertiesArgs:
    def __init__(__self__, *,
                 image: pulumi.Input[str],
                 command: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 environment: Optional[pulumi.Input[Sequence[pulumi.Input['JobDefinitionEnvironmentArgs']]]] = None,
                 execution_role_arn: Optional[pulumi.Input[str]] = None,
                 fargate_platform_configuration: Optional[pulumi.Input['JobDefinitionFargatePlatformConfigurationArgs']] = None,
                 instance_type: Optional[pulumi.Input[str]] = None,
                 job_role_arn: Optional[pulumi.Input[str]] = None,
                 linux_parameters: Optional[pulumi.Input['JobDefinitionLinuxParametersArgs']] = None,
                 log_configuration: Optional[pulumi.Input['JobDefinitionLogConfigurationArgs']] = None,
                 memory: Optional[pulumi.Input[int]] = None,
                 mount_points: Optional[pulumi.Input[Sequence[pulumi.Input['JobDefinitionMountPointsArgs']]]] = None,
                 network_configuration: Optional[pulumi.Input['JobDefinitionNetworkConfigurationArgs']] = None,
                 privileged: Optional[pulumi.Input[bool]] = None,
                 readonly_root_filesystem: Optional[pulumi.Input[bool]] = None,
                 resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input['JobDefinitionResourceRequirementArgs']]]] = None,
                 secrets: Optional[pulumi.Input[Sequence[pulumi.Input['JobDefinitionSecretArgs']]]] = None,
                 ulimits: Optional[pulumi.Input[Sequence[pulumi.Input['JobDefinitionUlimitArgs']]]] = None,
                 user: Optional[pulumi.Input[str]] = None,
                 vcpus: Optional[pulumi.Input[int]] = None,
                 volumes: Optional[pulumi.Input[Sequence[pulumi.Input['JobDefinitionVolumesArgs']]]] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "image")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class JobDefinitionDeviceArgs:
    def __init__(__self__, *,
                 container_path: Optional[pulumi.Input[str]] = None,
                 host_path: Optional[pulumi.Input[str]] = None,
                 permissions: Optional[pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "container_path")

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

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

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

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

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


@pulumi.input_type
class JobDefinitionEfsVolumeConfigurationArgs:
    def __init__(__self__, *,
                 file_system_id: pulumi.Input[str],
                 authorization_config: Optional[pulumi.Input['JobDefinitionAuthorizationConfigArgs']] = None,
                 root_directory: Optional[pulumi.Input[str]] = None,
                 transit_encryption: Optional[pulumi.Input[str]] = None,
                 transit_encryption_port: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "file_system_id")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class JobDefinitionEnvironmentArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[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[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 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 JobDefinitionEvaluateOnExitArgs:
    def __init__(__self__, *,
                 action: pulumi.Input[str],
                 on_exit_code: Optional[pulumi.Input[str]] = None,
                 on_reason: Optional[pulumi.Input[str]] = None,
                 on_status_reason: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "action")

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

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

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

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

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

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

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


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

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


@pulumi.input_type
class JobDefinitionLinuxParametersArgs:
    def __init__(__self__, *,
                 devices: Optional[pulumi.Input[Sequence[pulumi.Input['JobDefinitionDeviceArgs']]]] = None,
                 init_process_enabled: Optional[pulumi.Input[bool]] = None,
                 max_swap: Optional[pulumi.Input[int]] = None,
                 shared_memory_size: Optional[pulumi.Input[int]] = None,
                 swappiness: Optional[pulumi.Input[int]] = None,
                 tmpfs: Optional[pulumi.Input[Sequence[pulumi.Input['JobDefinitionTmpfsArgs']]]] = 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[pulumi.Input[Sequence[pulumi.Input['JobDefinitionDeviceArgs']]]]:
        return pulumi.get(self, "devices")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class JobDefinitionLogConfigurationArgs:
    def __init__(__self__, *,
                 log_driver: pulumi.Input[str],
                 options: Optional[Any] = None,
                 secret_options: Optional[pulumi.Input[Sequence[pulumi.Input['JobDefinitionSecretArgs']]]] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "log_driver")

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

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

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

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

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


@pulumi.input_type
class JobDefinitionMountPointsArgs:
    def __init__(__self__, *,
                 container_path: Optional[pulumi.Input[str]] = None,
                 read_only: Optional[pulumi.Input[bool]] = None,
                 source_volume: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "container_path")

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

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

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

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

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


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

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


@pulumi.input_type
class JobDefinitionNodePropertiesArgs:
    def __init__(__self__, *,
                 main_node: pulumi.Input[int],
                 node_range_properties: pulumi.Input[Sequence[pulumi.Input['JobDefinitionNodeRangePropertyArgs']]],
                 num_nodes: pulumi.Input[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) -> pulumi.Input[int]:
        return pulumi.get(self, "main_node")

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

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

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

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

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


@pulumi.input_type
class JobDefinitionNodeRangePropertyArgs:
    def __init__(__self__, *,
                 target_nodes: pulumi.Input[str],
                 container: Optional[pulumi.Input['JobDefinitionContainerPropertiesArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "target_nodes")

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

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

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


@pulumi.input_type
class JobDefinitionResourceRequirementArgs:
    def __init__(__self__, *,
                 type: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", 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 JobDefinitionRetryStrategyArgs:
    def __init__(__self__, *,
                 attempts: Optional[pulumi.Input[int]] = None,
                 evaluate_on_exit: Optional[pulumi.Input[Sequence[pulumi.Input['JobDefinitionEvaluateOnExitArgs']]]] = 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[pulumi.Input[int]]:
        return pulumi.get(self, "attempts")

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

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

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


@pulumi.input_type
class JobDefinitionSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value_from: pulumi.Input[str]):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value_from", value_from)

    @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="valueFrom")
    def value_from(self) -> pulumi.Input[str]:
        return pulumi.get(self, "value_from")

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


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

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


@pulumi.input_type
class JobDefinitionTmpfsArgs:
    def __init__(__self__, *,
                 container_path: pulumi.Input[str],
                 size: pulumi.Input[int],
                 mount_options: Optional[pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "container_path")

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

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

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

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

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


@pulumi.input_type
class JobDefinitionUlimitArgs:
    def __init__(__self__, *,
                 hard_limit: pulumi.Input[int],
                 name: pulumi.Input[str],
                 soft_limit: pulumi.Input[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) -> pulumi.Input[int]:
        return pulumi.get(self, "hard_limit")

    @hard_limit.setter
    def hard_limit(self, value: pulumi.Input[int]):
        pulumi.set(self, "hard_limit", 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="softLimit")
    def soft_limit(self) -> pulumi.Input[int]:
        return pulumi.get(self, "soft_limit")

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


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

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


@pulumi.input_type
class JobDefinitionVolumesArgs:
    def __init__(__self__, *,
                 efs_volume_configuration: Optional[pulumi.Input['JobDefinitionEfsVolumeConfigurationArgs']] = None,
                 host: Optional[pulumi.Input['JobDefinitionVolumesHostArgs']] = None,
                 name: Optional[pulumi.Input[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[pulumi.Input['JobDefinitionEfsVolumeConfigurationArgs']]:
        return pulumi.get(self, "efs_volume_configuration")

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

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

    @host.setter
    def host(self, value: Optional[pulumi.Input['JobDefinitionVolumesHostArgs']]):
        pulumi.set(self, "host", 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 JobQueueComputeEnvironmentOrderArgs:
    def __init__(__self__, *,
                 compute_environment: pulumi.Input[str],
                 order: pulumi.Input[int]):
        pulumi.set(__self__, "compute_environment", compute_environment)
        pulumi.set(__self__, "order", order)

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

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

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

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


