{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.ECS.Types.Task
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.ECS.Types.Task where

import qualified Amazonka.Core as Core
import Amazonka.ECS.Types.Attachment
import Amazonka.ECS.Types.Attribute
import Amazonka.ECS.Types.Connectivity
import Amazonka.ECS.Types.Container
import Amazonka.ECS.Types.EphemeralStorage
import Amazonka.ECS.Types.HealthStatus
import Amazonka.ECS.Types.InferenceAccelerator
import Amazonka.ECS.Types.LaunchType
import Amazonka.ECS.Types.Tag
import Amazonka.ECS.Types.TaskOverride
import Amazonka.ECS.Types.TaskStopCode
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude

-- | Details on a task in a cluster.
--
-- /See:/ 'newTask' smart constructor.
data Task = Task'
  { -- | The Unix timestamp for when the task was stopped (the task transitioned
    -- from the @RUNNING@ state to the @STOPPED@ state).
    Task -> Maybe POSIX
stoppedAt :: Prelude.Maybe Core.POSIX,
    -- | The desired status of the task. For more information, see
    -- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html Task Lifecycle>.
    Task -> Maybe Text
desiredStatus :: Prelude.Maybe Prelude.Text,
    -- | One or more container overrides.
    Task -> Maybe TaskOverride
overrides :: Prelude.Maybe TaskOverride,
    -- | The Elastic Inference accelerator associated with the task.
    Task -> Maybe [InferenceAccelerator]
inferenceAccelerators :: Prelude.Maybe [InferenceAccelerator],
    -- | The ARN of the cluster that hosts the task.
    Task -> Maybe Text
clusterArn :: Prelude.Maybe Prelude.Text,
    -- | The name of the task group associated with the task.
    Task -> Maybe Text
group' :: Prelude.Maybe Prelude.Text,
    -- | The Elastic Network Adapter associated with the task if the task uses
    -- the @awsvpc@ network mode.
    Task -> Maybe [Attachment]
attachments :: Prelude.Maybe [Attachment],
    -- | The Unix timestamp for when the task was created (the task entered the
    -- @PENDING@ state).
    Task -> Maybe POSIX
createdAt :: Prelude.Maybe Core.POSIX,
    -- | The stop code indicating why a task was stopped. The @stoppedReason@ may
    -- contain additional details.
    Task -> Maybe TaskStopCode
stopCode :: Prelude.Maybe TaskStopCode,
    -- | The platform version on which your task is running. A platform version
    -- is only specified for tasks using the Fargate launch type. If one is not
    -- specified, the @LATEST@ platform version is used by default. For more
    -- information, see
    -- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html Fargate Platform Versions>
    -- in the /Amazon Elastic Container Service Developer Guide/.
    Task -> Maybe Text
platformVersion :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the task.
    Task -> Maybe Text
taskArn :: Prelude.Maybe Prelude.Text,
    -- | The ARN of the container instances that host the task.
    Task -> Maybe Text
containerInstanceArn :: Prelude.Maybe Prelude.Text,
    -- | The Unix timestamp for when the task execution stopped.
    Task -> Maybe POSIX
executionStoppedAt :: Prelude.Maybe Core.POSIX,
    -- | The ephemeral storage settings for the task.
    Task -> Maybe EphemeralStorage
ephemeralStorage :: Prelude.Maybe EphemeralStorage,
    -- | The last known status of the task. For more information, see
    -- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html Task Lifecycle>.
    Task -> Maybe Text
lastStatus :: Prelude.Maybe Prelude.Text,
    -- | The amount of memory (in MiB) used by the task as expressed in a task
    -- definition. It can be expressed as an integer using MiB, for example
    -- @1024@. It can also be expressed as a string using GB, for example @1GB@
    -- or @1 GB@. String values are converted to an integer indicating the MiB
    -- when the task definition is registered.
    --
    -- If you are using the EC2 launch type, this field is optional.
    --
    -- If you are using the Fargate launch type, this field is required and you
    -- must use one of the following values, which determines your range of
    -- supported values for the @cpu@ parameter:
    --
    -- -   512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available @cpu@ values: 256
    --     (.25 vCPU)
    --
    -- -   1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available @cpu@
    --     values: 512 (.5 vCPU)
    --
    -- -   2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB),
    --     7168 (7 GB), 8192 (8 GB) - Available @cpu@ values: 1024 (1 vCPU)
    --
    -- -   Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) -
    --     Available @cpu@ values: 2048 (2 vCPU)
    --
    -- -   Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) -
    --     Available @cpu@ values: 4096 (4 vCPU)
    Task -> Maybe Text
memory :: Prelude.Maybe Prelude.Text,
    -- | The Unix timestamp for when the container image pull completed.
    Task -> Maybe POSIX
pullStoppedAt :: Prelude.Maybe Core.POSIX,
    -- | The containers associated with the task.
    Task -> Maybe [Container]
containers :: Prelude.Maybe [Container],
    -- | The Unix timestamp for when the task started (the task transitioned from
    -- the @PENDING@ state to the @RUNNING@ state).
    Task -> Maybe POSIX
startedAt :: Prelude.Maybe Core.POSIX,
    -- | The availability zone of the task.
    Task -> Maybe Text
availabilityZone :: Prelude.Maybe Prelude.Text,
    -- | The attributes of the task
    Task -> Maybe [Attribute]
attributes :: Prelude.Maybe [Attribute],
    -- | The version counter for the task. Every time a task experiences a change
    -- that triggers a CloudWatch event, the version counter is incremented. If
    -- you are replicating your Amazon ECS task state with CloudWatch Events,
    -- you can compare the version of a task reported by the Amazon ECS API
    -- actions with the version reported in CloudWatch Events for the task
    -- (inside the @detail@ object) to verify that the version in your event
    -- stream is current.
    Task -> Maybe Integer
version :: Prelude.Maybe Prelude.Integer,
    -- | The capacity provider associated with the task.
    Task -> Maybe Text
capacityProviderName :: Prelude.Maybe Prelude.Text,
    -- | The tag specified when a task is started. If the task is started by an
    -- Amazon ECS service, then the @startedBy@ parameter contains the
    -- deployment ID of the service that starts it.
    Task -> Maybe Text
startedBy :: Prelude.Maybe Prelude.Text,
    -- | The reason that the task was stopped.
    Task -> Maybe Text
stoppedReason :: Prelude.Maybe Prelude.Text,
    -- | The connectivity status of a task.
    Task -> Maybe Connectivity
connectivity :: Prelude.Maybe Connectivity,
    -- | The Unix timestamp for when the task stops (transitions from the
    -- @RUNNING@ state to @STOPPED@).
    Task -> Maybe POSIX
stoppingAt :: Prelude.Maybe Core.POSIX,
    -- | The infrastructure on which your task is running. For more information,
    -- see
    -- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html Amazon ECS launch types>
    -- in the /Amazon Elastic Container Service Developer Guide/.
    Task -> Maybe LaunchType
launchType :: Prelude.Maybe LaunchType,
    -- | The ARN of the task definition that creates the task.
    Task -> Maybe Text
taskDefinitionArn :: Prelude.Maybe Prelude.Text,
    -- | The health status for the task, which is determined by the health of the
    -- essential containers in the task. If all essential containers in the
    -- task are reporting as @HEALTHY@, then the task status also reports as
    -- @HEALTHY@. If any essential containers in the task are reporting as
    -- @UNHEALTHY@ or @UNKNOWN@, then the task status also reports as
    -- @UNHEALTHY@ or @UNKNOWN@, accordingly.
    --
    -- The Amazon ECS container agent does not monitor or report on Docker
    -- health checks that are embedded in a container image (such as those
    -- specified in a parent image or from the image\'s Dockerfile) and not
    -- specified in the container definition. Health check parameters that are
    -- specified in a container definition override any Docker health checks
    -- that exist in the container image.
    Task -> Maybe HealthStatus
healthStatus :: Prelude.Maybe HealthStatus,
    -- | The Unix timestamp for when the task last went into @CONNECTED@ status.
    Task -> Maybe POSIX
connectivityAt :: Prelude.Maybe Core.POSIX,
    -- | The number of CPU units used by the task as expressed in a task
    -- definition. It can be expressed as an integer using CPU units, for
    -- example @1024@. It can also be expressed as a string using vCPUs, for
    -- example @1 vCPU@ or @1 vcpu@. String values are converted to an integer
    -- indicating the CPU units when the task definition is registered.
    --
    -- If you are using the EC2 launch type, this field is optional. Supported
    -- values are between @128@ CPU units (@0.125@ vCPUs) and @10240@ CPU units
    -- (@10@ vCPUs).
    --
    -- If you are using the Fargate launch type, this field is required and you
    -- must use one of the following values, which determines your range of
    -- supported values for the @memory@ parameter:
    --
    -- -   256 (.25 vCPU) - Available @memory@ values: 512 (0.5 GB), 1024 (1
    --     GB), 2048 (2 GB)
    --
    -- -   512 (.5 vCPU) - Available @memory@ values: 1024 (1 GB), 2048 (2 GB),
    --     3072 (3 GB), 4096 (4 GB)
    --
    -- -   1024 (1 vCPU) - Available @memory@ values: 2048 (2 GB), 3072 (3 GB),
    --     4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)
    --
    -- -   2048 (2 vCPU) - Available @memory@ values: Between 4096 (4 GB) and
    --     16384 (16 GB) in increments of 1024 (1 GB)
    --
    -- -   4096 (4 vCPU) - Available @memory@ values: Between 8192 (8 GB) and
    --     30720 (30 GB) in increments of 1024 (1 GB)
    Task -> Maybe Text
cpu :: Prelude.Maybe Prelude.Text,
    -- | Whether or not execute command functionality is enabled for this task.
    -- If @true@, this enables execute command functionality on all containers
    -- in the task.
    Task -> Maybe Bool
enableExecuteCommand :: Prelude.Maybe Prelude.Bool,
    -- | The Unix timestamp for when the container image pull began.
    Task -> Maybe POSIX
pullStartedAt :: Prelude.Maybe Core.POSIX,
    -- | The metadata that you apply to the task to help you categorize and
    -- organize them. Each tag consists of a key and an optional value, both of
    -- which you define.
    --
    -- The following basic restrictions apply to tags:
    --
    -- -   Maximum number of tags per resource - 50
    --
    -- -   For each resource, each tag key must be unique, and each tag key can
    --     have only one value.
    --
    -- -   Maximum key length - 128 Unicode characters in UTF-8
    --
    -- -   Maximum value length - 256 Unicode characters in UTF-8
    --
    -- -   If your tagging schema is used across multiple services and
    --     resources, remember that other services may have restrictions on
    --     allowed characters. Generally allowed characters are: letters,
    --     numbers, and spaces representable in UTF-8, and the following
    --     characters: + - = . _ : \/ \@.
    --
    -- -   Tag keys and values are case-sensitive.
    --
    -- -   Do not use @aws:@, @AWS:@, or any upper or lowercase combination of
    --     such as a prefix for either keys or values as it is reserved for
    --     Amazon Web Services use. You cannot edit or delete tag keys or
    --     values with this prefix. Tags with this prefix do not count against
    --     your tags per resource limit.
    Task -> Maybe [Tag]
tags :: Prelude.Maybe [Tag]
  }
  deriving (Task -> Task -> Bool
(Task -> Task -> Bool) -> (Task -> Task -> Bool) -> Eq Task
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Task -> Task -> Bool
$c/= :: Task -> Task -> Bool
== :: Task -> Task -> Bool
$c== :: Task -> Task -> Bool
Prelude.Eq, ReadPrec [Task]
ReadPrec Task
Int -> ReadS Task
ReadS [Task]
(Int -> ReadS Task)
-> ReadS [Task] -> ReadPrec Task -> ReadPrec [Task] -> Read Task
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Task]
$creadListPrec :: ReadPrec [Task]
readPrec :: ReadPrec Task
$creadPrec :: ReadPrec Task
readList :: ReadS [Task]
$creadList :: ReadS [Task]
readsPrec :: Int -> ReadS Task
$creadsPrec :: Int -> ReadS Task
Prelude.Read, Int -> Task -> ShowS
[Task] -> ShowS
Task -> String
(Int -> Task -> ShowS)
-> (Task -> String) -> ([Task] -> ShowS) -> Show Task
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Task] -> ShowS
$cshowList :: [Task] -> ShowS
show :: Task -> String
$cshow :: Task -> String
showsPrec :: Int -> Task -> ShowS
$cshowsPrec :: Int -> Task -> ShowS
Prelude.Show, (forall x. Task -> Rep Task x)
-> (forall x. Rep Task x -> Task) -> Generic Task
forall x. Rep Task x -> Task
forall x. Task -> Rep Task x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Task x -> Task
$cfrom :: forall x. Task -> Rep Task x
Prelude.Generic)

-- |
-- Create a value of 'Task' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'stoppedAt', 'task_stoppedAt' - The Unix timestamp for when the task was stopped (the task transitioned
-- from the @RUNNING@ state to the @STOPPED@ state).
--
-- 'desiredStatus', 'task_desiredStatus' - The desired status of the task. For more information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html Task Lifecycle>.
--
-- 'overrides', 'task_overrides' - One or more container overrides.
--
-- 'inferenceAccelerators', 'task_inferenceAccelerators' - The Elastic Inference accelerator associated with the task.
--
-- 'clusterArn', 'task_clusterArn' - The ARN of the cluster that hosts the task.
--
-- 'group'', 'task_group' - The name of the task group associated with the task.
--
-- 'attachments', 'task_attachments' - The Elastic Network Adapter associated with the task if the task uses
-- the @awsvpc@ network mode.
--
-- 'createdAt', 'task_createdAt' - The Unix timestamp for when the task was created (the task entered the
-- @PENDING@ state).
--
-- 'stopCode', 'task_stopCode' - The stop code indicating why a task was stopped. The @stoppedReason@ may
-- contain additional details.
--
-- 'platformVersion', 'task_platformVersion' - The platform version on which your task is running. A platform version
-- is only specified for tasks using the Fargate launch type. If one is not
-- specified, the @LATEST@ platform version is used by default. For more
-- information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html Fargate Platform Versions>
-- in the /Amazon Elastic Container Service Developer Guide/.
--
-- 'taskArn', 'task_taskArn' - The Amazon Resource Name (ARN) of the task.
--
-- 'containerInstanceArn', 'task_containerInstanceArn' - The ARN of the container instances that host the task.
--
-- 'executionStoppedAt', 'task_executionStoppedAt' - The Unix timestamp for when the task execution stopped.
--
-- 'ephemeralStorage', 'task_ephemeralStorage' - The ephemeral storage settings for the task.
--
-- 'lastStatus', 'task_lastStatus' - The last known status of the task. For more information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html Task Lifecycle>.
--
-- 'memory', 'task_memory' - The amount of memory (in MiB) used by the task as expressed in a task
-- definition. It can be expressed as an integer using MiB, for example
-- @1024@. It can also be expressed as a string using GB, for example @1GB@
-- or @1 GB@. String values are converted to an integer indicating the MiB
-- when the task definition is registered.
--
-- If you are using the EC2 launch type, this field is optional.
--
-- If you are using the Fargate launch type, this field is required and you
-- must use one of the following values, which determines your range of
-- supported values for the @cpu@ parameter:
--
-- -   512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available @cpu@ values: 256
--     (.25 vCPU)
--
-- -   1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available @cpu@
--     values: 512 (.5 vCPU)
--
-- -   2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB),
--     7168 (7 GB), 8192 (8 GB) - Available @cpu@ values: 1024 (1 vCPU)
--
-- -   Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) -
--     Available @cpu@ values: 2048 (2 vCPU)
--
-- -   Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) -
--     Available @cpu@ values: 4096 (4 vCPU)
--
-- 'pullStoppedAt', 'task_pullStoppedAt' - The Unix timestamp for when the container image pull completed.
--
-- 'containers', 'task_containers' - The containers associated with the task.
--
-- 'startedAt', 'task_startedAt' - The Unix timestamp for when the task started (the task transitioned from
-- the @PENDING@ state to the @RUNNING@ state).
--
-- 'availabilityZone', 'task_availabilityZone' - The availability zone of the task.
--
-- 'attributes', 'task_attributes' - The attributes of the task
--
-- 'version', 'task_version' - The version counter for the task. Every time a task experiences a change
-- that triggers a CloudWatch event, the version counter is incremented. If
-- you are replicating your Amazon ECS task state with CloudWatch Events,
-- you can compare the version of a task reported by the Amazon ECS API
-- actions with the version reported in CloudWatch Events for the task
-- (inside the @detail@ object) to verify that the version in your event
-- stream is current.
--
-- 'capacityProviderName', 'task_capacityProviderName' - The capacity provider associated with the task.
--
-- 'startedBy', 'task_startedBy' - The tag specified when a task is started. If the task is started by an
-- Amazon ECS service, then the @startedBy@ parameter contains the
-- deployment ID of the service that starts it.
--
-- 'stoppedReason', 'task_stoppedReason' - The reason that the task was stopped.
--
-- 'connectivity', 'task_connectivity' - The connectivity status of a task.
--
-- 'stoppingAt', 'task_stoppingAt' - The Unix timestamp for when the task stops (transitions from the
-- @RUNNING@ state to @STOPPED@).
--
-- 'launchType', 'task_launchType' - The infrastructure on which your task is running. For more information,
-- see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html Amazon ECS launch types>
-- in the /Amazon Elastic Container Service Developer Guide/.
--
-- 'taskDefinitionArn', 'task_taskDefinitionArn' - The ARN of the task definition that creates the task.
--
-- 'healthStatus', 'task_healthStatus' - The health status for the task, which is determined by the health of the
-- essential containers in the task. If all essential containers in the
-- task are reporting as @HEALTHY@, then the task status also reports as
-- @HEALTHY@. If any essential containers in the task are reporting as
-- @UNHEALTHY@ or @UNKNOWN@, then the task status also reports as
-- @UNHEALTHY@ or @UNKNOWN@, accordingly.
--
-- The Amazon ECS container agent does not monitor or report on Docker
-- health checks that are embedded in a container image (such as those
-- specified in a parent image or from the image\'s Dockerfile) and not
-- specified in the container definition. Health check parameters that are
-- specified in a container definition override any Docker health checks
-- that exist in the container image.
--
-- 'connectivityAt', 'task_connectivityAt' - The Unix timestamp for when the task last went into @CONNECTED@ status.
--
-- 'cpu', 'task_cpu' - The number of CPU units used by the task as expressed in a task
-- definition. It can be expressed as an integer using CPU units, for
-- example @1024@. It can also be expressed as a string using vCPUs, for
-- example @1 vCPU@ or @1 vcpu@. String values are converted to an integer
-- indicating the CPU units when the task definition is registered.
--
-- If you are using the EC2 launch type, this field is optional. Supported
-- values are between @128@ CPU units (@0.125@ vCPUs) and @10240@ CPU units
-- (@10@ vCPUs).
--
-- If you are using the Fargate launch type, this field is required and you
-- must use one of the following values, which determines your range of
-- supported values for the @memory@ parameter:
--
-- -   256 (.25 vCPU) - Available @memory@ values: 512 (0.5 GB), 1024 (1
--     GB), 2048 (2 GB)
--
-- -   512 (.5 vCPU) - Available @memory@ values: 1024 (1 GB), 2048 (2 GB),
--     3072 (3 GB), 4096 (4 GB)
--
-- -   1024 (1 vCPU) - Available @memory@ values: 2048 (2 GB), 3072 (3 GB),
--     4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)
--
-- -   2048 (2 vCPU) - Available @memory@ values: Between 4096 (4 GB) and
--     16384 (16 GB) in increments of 1024 (1 GB)
--
-- -   4096 (4 vCPU) - Available @memory@ values: Between 8192 (8 GB) and
--     30720 (30 GB) in increments of 1024 (1 GB)
--
-- 'enableExecuteCommand', 'task_enableExecuteCommand' - Whether or not execute command functionality is enabled for this task.
-- If @true@, this enables execute command functionality on all containers
-- in the task.
--
-- 'pullStartedAt', 'task_pullStartedAt' - The Unix timestamp for when the container image pull began.
--
-- 'tags', 'task_tags' - The metadata that you apply to the task to help you categorize and
-- organize them. Each tag consists of a key and an optional value, both of
-- which you define.
--
-- The following basic restrictions apply to tags:
--
-- -   Maximum number of tags per resource - 50
--
-- -   For each resource, each tag key must be unique, and each tag key can
--     have only one value.
--
-- -   Maximum key length - 128 Unicode characters in UTF-8
--
-- -   Maximum value length - 256 Unicode characters in UTF-8
--
-- -   If your tagging schema is used across multiple services and
--     resources, remember that other services may have restrictions on
--     allowed characters. Generally allowed characters are: letters,
--     numbers, and spaces representable in UTF-8, and the following
--     characters: + - = . _ : \/ \@.
--
-- -   Tag keys and values are case-sensitive.
--
-- -   Do not use @aws:@, @AWS:@, or any upper or lowercase combination of
--     such as a prefix for either keys or values as it is reserved for
--     Amazon Web Services use. You cannot edit or delete tag keys or
--     values with this prefix. Tags with this prefix do not count against
--     your tags per resource limit.
newTask ::
  Task
newTask :: Task
newTask =
  Task' :: Maybe POSIX
-> Maybe Text
-> Maybe TaskOverride
-> Maybe [InferenceAccelerator]
-> Maybe Text
-> Maybe Text
-> Maybe [Attachment]
-> Maybe POSIX
-> Maybe TaskStopCode
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe POSIX
-> Maybe EphemeralStorage
-> Maybe Text
-> Maybe Text
-> Maybe POSIX
-> Maybe [Container]
-> Maybe POSIX
-> Maybe Text
-> Maybe [Attribute]
-> Maybe Integer
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Connectivity
-> Maybe POSIX
-> Maybe LaunchType
-> Maybe Text
-> Maybe HealthStatus
-> Maybe POSIX
-> Maybe Text
-> Maybe Bool
-> Maybe POSIX
-> Maybe [Tag]
-> Task
Task'
    { $sel:stoppedAt:Task' :: Maybe POSIX
stoppedAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:desiredStatus:Task' :: Maybe Text
desiredStatus = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:overrides:Task' :: Maybe TaskOverride
overrides = Maybe TaskOverride
forall a. Maybe a
Prelude.Nothing,
      $sel:inferenceAccelerators:Task' :: Maybe [InferenceAccelerator]
inferenceAccelerators = Maybe [InferenceAccelerator]
forall a. Maybe a
Prelude.Nothing,
      $sel:clusterArn:Task' :: Maybe Text
clusterArn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:group':Task' :: Maybe Text
group' = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:attachments:Task' :: Maybe [Attachment]
attachments = Maybe [Attachment]
forall a. Maybe a
Prelude.Nothing,
      $sel:createdAt:Task' :: Maybe POSIX
createdAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:stopCode:Task' :: Maybe TaskStopCode
stopCode = Maybe TaskStopCode
forall a. Maybe a
Prelude.Nothing,
      $sel:platformVersion:Task' :: Maybe Text
platformVersion = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:taskArn:Task' :: Maybe Text
taskArn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:containerInstanceArn:Task' :: Maybe Text
containerInstanceArn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:executionStoppedAt:Task' :: Maybe POSIX
executionStoppedAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:ephemeralStorage:Task' :: Maybe EphemeralStorage
ephemeralStorage = Maybe EphemeralStorage
forall a. Maybe a
Prelude.Nothing,
      $sel:lastStatus:Task' :: Maybe Text
lastStatus = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:memory:Task' :: Maybe Text
memory = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:pullStoppedAt:Task' :: Maybe POSIX
pullStoppedAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:containers:Task' :: Maybe [Container]
containers = Maybe [Container]
forall a. Maybe a
Prelude.Nothing,
      $sel:startedAt:Task' :: Maybe POSIX
startedAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:availabilityZone:Task' :: Maybe Text
availabilityZone = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:attributes:Task' :: Maybe [Attribute]
attributes = Maybe [Attribute]
forall a. Maybe a
Prelude.Nothing,
      $sel:version:Task' :: Maybe Integer
version = Maybe Integer
forall a. Maybe a
Prelude.Nothing,
      $sel:capacityProviderName:Task' :: Maybe Text
capacityProviderName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:startedBy:Task' :: Maybe Text
startedBy = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:stoppedReason:Task' :: Maybe Text
stoppedReason = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:connectivity:Task' :: Maybe Connectivity
connectivity = Maybe Connectivity
forall a. Maybe a
Prelude.Nothing,
      $sel:stoppingAt:Task' :: Maybe POSIX
stoppingAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:launchType:Task' :: Maybe LaunchType
launchType = Maybe LaunchType
forall a. Maybe a
Prelude.Nothing,
      $sel:taskDefinitionArn:Task' :: Maybe Text
taskDefinitionArn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:healthStatus:Task' :: Maybe HealthStatus
healthStatus = Maybe HealthStatus
forall a. Maybe a
Prelude.Nothing,
      $sel:connectivityAt:Task' :: Maybe POSIX
connectivityAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:cpu:Task' :: Maybe Text
cpu = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:enableExecuteCommand:Task' :: Maybe Bool
enableExecuteCommand = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:pullStartedAt:Task' :: Maybe POSIX
pullStartedAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:tags:Task' :: Maybe [Tag]
tags = Maybe [Tag]
forall a. Maybe a
Prelude.Nothing
    }

-- | The Unix timestamp for when the task was stopped (the task transitioned
-- from the @RUNNING@ state to the @STOPPED@ state).
task_stoppedAt :: Lens.Lens' Task (Prelude.Maybe Prelude.UTCTime)
task_stoppedAt :: (Maybe UTCTime -> f (Maybe UTCTime)) -> Task -> f Task
task_stoppedAt = (Task -> Maybe POSIX)
-> (Task -> Maybe POSIX -> Task)
-> Lens Task Task (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe POSIX
stoppedAt :: Maybe POSIX
$sel:stoppedAt:Task' :: Task -> Maybe POSIX
stoppedAt} -> Maybe POSIX
stoppedAt) (\s :: Task
s@Task' {} Maybe POSIX
a -> Task
s {$sel:stoppedAt:Task' :: Maybe POSIX
stoppedAt = Maybe POSIX
a} :: Task) ((Maybe POSIX -> f (Maybe POSIX)) -> Task -> f Task)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The desired status of the task. For more information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html Task Lifecycle>.
task_desiredStatus :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_desiredStatus :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_desiredStatus = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
desiredStatus :: Maybe Text
$sel:desiredStatus:Task' :: Task -> Maybe Text
desiredStatus} -> Maybe Text
desiredStatus) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:desiredStatus:Task' :: Maybe Text
desiredStatus = Maybe Text
a} :: Task)

-- | One or more container overrides.
task_overrides :: Lens.Lens' Task (Prelude.Maybe TaskOverride)
task_overrides :: (Maybe TaskOverride -> f (Maybe TaskOverride)) -> Task -> f Task
task_overrides = (Task -> Maybe TaskOverride)
-> (Task -> Maybe TaskOverride -> Task)
-> Lens Task Task (Maybe TaskOverride) (Maybe TaskOverride)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe TaskOverride
overrides :: Maybe TaskOverride
$sel:overrides:Task' :: Task -> Maybe TaskOverride
overrides} -> Maybe TaskOverride
overrides) (\s :: Task
s@Task' {} Maybe TaskOverride
a -> Task
s {$sel:overrides:Task' :: Maybe TaskOverride
overrides = Maybe TaskOverride
a} :: Task)

-- | The Elastic Inference accelerator associated with the task.
task_inferenceAccelerators :: Lens.Lens' Task (Prelude.Maybe [InferenceAccelerator])
task_inferenceAccelerators :: (Maybe [InferenceAccelerator] -> f (Maybe [InferenceAccelerator]))
-> Task -> f Task
task_inferenceAccelerators = (Task -> Maybe [InferenceAccelerator])
-> (Task -> Maybe [InferenceAccelerator] -> Task)
-> Lens
     Task
     Task
     (Maybe [InferenceAccelerator])
     (Maybe [InferenceAccelerator])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe [InferenceAccelerator]
inferenceAccelerators :: Maybe [InferenceAccelerator]
$sel:inferenceAccelerators:Task' :: Task -> Maybe [InferenceAccelerator]
inferenceAccelerators} -> Maybe [InferenceAccelerator]
inferenceAccelerators) (\s :: Task
s@Task' {} Maybe [InferenceAccelerator]
a -> Task
s {$sel:inferenceAccelerators:Task' :: Maybe [InferenceAccelerator]
inferenceAccelerators = Maybe [InferenceAccelerator]
a} :: Task) ((Maybe [InferenceAccelerator] -> f (Maybe [InferenceAccelerator]))
 -> Task -> f Task)
-> ((Maybe [InferenceAccelerator]
     -> f (Maybe [InferenceAccelerator]))
    -> Maybe [InferenceAccelerator]
    -> f (Maybe [InferenceAccelerator]))
-> (Maybe [InferenceAccelerator]
    -> f (Maybe [InferenceAccelerator]))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [InferenceAccelerator]
  [InferenceAccelerator]
  [InferenceAccelerator]
  [InferenceAccelerator]
-> Iso
     (Maybe [InferenceAccelerator])
     (Maybe [InferenceAccelerator])
     (Maybe [InferenceAccelerator])
     (Maybe [InferenceAccelerator])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso
  [InferenceAccelerator]
  [InferenceAccelerator]
  [InferenceAccelerator]
  [InferenceAccelerator]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The ARN of the cluster that hosts the task.
task_clusterArn :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_clusterArn :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_clusterArn = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
clusterArn :: Maybe Text
$sel:clusterArn:Task' :: Task -> Maybe Text
clusterArn} -> Maybe Text
clusterArn) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:clusterArn:Task' :: Maybe Text
clusterArn = Maybe Text
a} :: Task)

-- | The name of the task group associated with the task.
task_group :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_group :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_group = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
group' :: Maybe Text
$sel:group':Task' :: Task -> Maybe Text
group'} -> Maybe Text
group') (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:group':Task' :: Maybe Text
group' = Maybe Text
a} :: Task)

-- | The Elastic Network Adapter associated with the task if the task uses
-- the @awsvpc@ network mode.
task_attachments :: Lens.Lens' Task (Prelude.Maybe [Attachment])
task_attachments :: (Maybe [Attachment] -> f (Maybe [Attachment])) -> Task -> f Task
task_attachments = (Task -> Maybe [Attachment])
-> (Task -> Maybe [Attachment] -> Task)
-> Lens Task Task (Maybe [Attachment]) (Maybe [Attachment])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe [Attachment]
attachments :: Maybe [Attachment]
$sel:attachments:Task' :: Task -> Maybe [Attachment]
attachments} -> Maybe [Attachment]
attachments) (\s :: Task
s@Task' {} Maybe [Attachment]
a -> Task
s {$sel:attachments:Task' :: Maybe [Attachment]
attachments = Maybe [Attachment]
a} :: Task) ((Maybe [Attachment] -> f (Maybe [Attachment])) -> Task -> f Task)
-> ((Maybe [Attachment] -> f (Maybe [Attachment]))
    -> Maybe [Attachment] -> f (Maybe [Attachment]))
-> (Maybe [Attachment] -> f (Maybe [Attachment]))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Attachment] [Attachment] [Attachment] [Attachment]
-> Iso
     (Maybe [Attachment])
     (Maybe [Attachment])
     (Maybe [Attachment])
     (Maybe [Attachment])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Attachment] [Attachment] [Attachment] [Attachment]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The Unix timestamp for when the task was created (the task entered the
-- @PENDING@ state).
task_createdAt :: Lens.Lens' Task (Prelude.Maybe Prelude.UTCTime)
task_createdAt :: (Maybe UTCTime -> f (Maybe UTCTime)) -> Task -> f Task
task_createdAt = (Task -> Maybe POSIX)
-> (Task -> Maybe POSIX -> Task)
-> Lens Task Task (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe POSIX
createdAt :: Maybe POSIX
$sel:createdAt:Task' :: Task -> Maybe POSIX
createdAt} -> Maybe POSIX
createdAt) (\s :: Task
s@Task' {} Maybe POSIX
a -> Task
s {$sel:createdAt:Task' :: Maybe POSIX
createdAt = Maybe POSIX
a} :: Task) ((Maybe POSIX -> f (Maybe POSIX)) -> Task -> f Task)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The stop code indicating why a task was stopped. The @stoppedReason@ may
-- contain additional details.
task_stopCode :: Lens.Lens' Task (Prelude.Maybe TaskStopCode)
task_stopCode :: (Maybe TaskStopCode -> f (Maybe TaskStopCode)) -> Task -> f Task
task_stopCode = (Task -> Maybe TaskStopCode)
-> (Task -> Maybe TaskStopCode -> Task)
-> Lens Task Task (Maybe TaskStopCode) (Maybe TaskStopCode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe TaskStopCode
stopCode :: Maybe TaskStopCode
$sel:stopCode:Task' :: Task -> Maybe TaskStopCode
stopCode} -> Maybe TaskStopCode
stopCode) (\s :: Task
s@Task' {} Maybe TaskStopCode
a -> Task
s {$sel:stopCode:Task' :: Maybe TaskStopCode
stopCode = Maybe TaskStopCode
a} :: Task)

-- | The platform version on which your task is running. A platform version
-- is only specified for tasks using the Fargate launch type. If one is not
-- specified, the @LATEST@ platform version is used by default. For more
-- information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html Fargate Platform Versions>
-- in the /Amazon Elastic Container Service Developer Guide/.
task_platformVersion :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_platformVersion :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_platformVersion = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
platformVersion :: Maybe Text
$sel:platformVersion:Task' :: Task -> Maybe Text
platformVersion} -> Maybe Text
platformVersion) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:platformVersion:Task' :: Maybe Text
platformVersion = Maybe Text
a} :: Task)

-- | The Amazon Resource Name (ARN) of the task.
task_taskArn :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_taskArn :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_taskArn = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
taskArn :: Maybe Text
$sel:taskArn:Task' :: Task -> Maybe Text
taskArn} -> Maybe Text
taskArn) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:taskArn:Task' :: Maybe Text
taskArn = Maybe Text
a} :: Task)

-- | The ARN of the container instances that host the task.
task_containerInstanceArn :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_containerInstanceArn :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_containerInstanceArn = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
containerInstanceArn :: Maybe Text
$sel:containerInstanceArn:Task' :: Task -> Maybe Text
containerInstanceArn} -> Maybe Text
containerInstanceArn) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:containerInstanceArn:Task' :: Maybe Text
containerInstanceArn = Maybe Text
a} :: Task)

-- | The Unix timestamp for when the task execution stopped.
task_executionStoppedAt :: Lens.Lens' Task (Prelude.Maybe Prelude.UTCTime)
task_executionStoppedAt :: (Maybe UTCTime -> f (Maybe UTCTime)) -> Task -> f Task
task_executionStoppedAt = (Task -> Maybe POSIX)
-> (Task -> Maybe POSIX -> Task)
-> Lens Task Task (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe POSIX
executionStoppedAt :: Maybe POSIX
$sel:executionStoppedAt:Task' :: Task -> Maybe POSIX
executionStoppedAt} -> Maybe POSIX
executionStoppedAt) (\s :: Task
s@Task' {} Maybe POSIX
a -> Task
s {$sel:executionStoppedAt:Task' :: Maybe POSIX
executionStoppedAt = Maybe POSIX
a} :: Task) ((Maybe POSIX -> f (Maybe POSIX)) -> Task -> f Task)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The ephemeral storage settings for the task.
task_ephemeralStorage :: Lens.Lens' Task (Prelude.Maybe EphemeralStorage)
task_ephemeralStorage :: (Maybe EphemeralStorage -> f (Maybe EphemeralStorage))
-> Task -> f Task
task_ephemeralStorage = (Task -> Maybe EphemeralStorage)
-> (Task -> Maybe EphemeralStorage -> Task)
-> Lens Task Task (Maybe EphemeralStorage) (Maybe EphemeralStorage)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe EphemeralStorage
ephemeralStorage :: Maybe EphemeralStorage
$sel:ephemeralStorage:Task' :: Task -> Maybe EphemeralStorage
ephemeralStorage} -> Maybe EphemeralStorage
ephemeralStorage) (\s :: Task
s@Task' {} Maybe EphemeralStorage
a -> Task
s {$sel:ephemeralStorage:Task' :: Maybe EphemeralStorage
ephemeralStorage = Maybe EphemeralStorage
a} :: Task)

-- | The last known status of the task. For more information, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle.html Task Lifecycle>.
task_lastStatus :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_lastStatus :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_lastStatus = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
lastStatus :: Maybe Text
$sel:lastStatus:Task' :: Task -> Maybe Text
lastStatus} -> Maybe Text
lastStatus) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:lastStatus:Task' :: Maybe Text
lastStatus = Maybe Text
a} :: Task)

-- | The amount of memory (in MiB) used by the task as expressed in a task
-- definition. It can be expressed as an integer using MiB, for example
-- @1024@. It can also be expressed as a string using GB, for example @1GB@
-- or @1 GB@. String values are converted to an integer indicating the MiB
-- when the task definition is registered.
--
-- If you are using the EC2 launch type, this field is optional.
--
-- If you are using the Fargate launch type, this field is required and you
-- must use one of the following values, which determines your range of
-- supported values for the @cpu@ parameter:
--
-- -   512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available @cpu@ values: 256
--     (.25 vCPU)
--
-- -   1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available @cpu@
--     values: 512 (.5 vCPU)
--
-- -   2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB),
--     7168 (7 GB), 8192 (8 GB) - Available @cpu@ values: 1024 (1 vCPU)
--
-- -   Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) -
--     Available @cpu@ values: 2048 (2 vCPU)
--
-- -   Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) -
--     Available @cpu@ values: 4096 (4 vCPU)
task_memory :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_memory :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_memory = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
memory :: Maybe Text
$sel:memory:Task' :: Task -> Maybe Text
memory} -> Maybe Text
memory) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:memory:Task' :: Maybe Text
memory = Maybe Text
a} :: Task)

-- | The Unix timestamp for when the container image pull completed.
task_pullStoppedAt :: Lens.Lens' Task (Prelude.Maybe Prelude.UTCTime)
task_pullStoppedAt :: (Maybe UTCTime -> f (Maybe UTCTime)) -> Task -> f Task
task_pullStoppedAt = (Task -> Maybe POSIX)
-> (Task -> Maybe POSIX -> Task)
-> Lens Task Task (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe POSIX
pullStoppedAt :: Maybe POSIX
$sel:pullStoppedAt:Task' :: Task -> Maybe POSIX
pullStoppedAt} -> Maybe POSIX
pullStoppedAt) (\s :: Task
s@Task' {} Maybe POSIX
a -> Task
s {$sel:pullStoppedAt:Task' :: Maybe POSIX
pullStoppedAt = Maybe POSIX
a} :: Task) ((Maybe POSIX -> f (Maybe POSIX)) -> Task -> f Task)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The containers associated with the task.
task_containers :: Lens.Lens' Task (Prelude.Maybe [Container])
task_containers :: (Maybe [Container] -> f (Maybe [Container])) -> Task -> f Task
task_containers = (Task -> Maybe [Container])
-> (Task -> Maybe [Container] -> Task)
-> Lens Task Task (Maybe [Container]) (Maybe [Container])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe [Container]
containers :: Maybe [Container]
$sel:containers:Task' :: Task -> Maybe [Container]
containers} -> Maybe [Container]
containers) (\s :: Task
s@Task' {} Maybe [Container]
a -> Task
s {$sel:containers:Task' :: Maybe [Container]
containers = Maybe [Container]
a} :: Task) ((Maybe [Container] -> f (Maybe [Container])) -> Task -> f Task)
-> ((Maybe [Container] -> f (Maybe [Container]))
    -> Maybe [Container] -> f (Maybe [Container]))
-> (Maybe [Container] -> f (Maybe [Container]))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Container] [Container] [Container] [Container]
-> Iso
     (Maybe [Container])
     (Maybe [Container])
     (Maybe [Container])
     (Maybe [Container])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Container] [Container] [Container] [Container]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The Unix timestamp for when the task started (the task transitioned from
-- the @PENDING@ state to the @RUNNING@ state).
task_startedAt :: Lens.Lens' Task (Prelude.Maybe Prelude.UTCTime)
task_startedAt :: (Maybe UTCTime -> f (Maybe UTCTime)) -> Task -> f Task
task_startedAt = (Task -> Maybe POSIX)
-> (Task -> Maybe POSIX -> Task)
-> Lens Task Task (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe POSIX
startedAt :: Maybe POSIX
$sel:startedAt:Task' :: Task -> Maybe POSIX
startedAt} -> Maybe POSIX
startedAt) (\s :: Task
s@Task' {} Maybe POSIX
a -> Task
s {$sel:startedAt:Task' :: Maybe POSIX
startedAt = Maybe POSIX
a} :: Task) ((Maybe POSIX -> f (Maybe POSIX)) -> Task -> f Task)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The availability zone of the task.
task_availabilityZone :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_availabilityZone :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_availabilityZone = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
availabilityZone :: Maybe Text
$sel:availabilityZone:Task' :: Task -> Maybe Text
availabilityZone} -> Maybe Text
availabilityZone) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:availabilityZone:Task' :: Maybe Text
availabilityZone = Maybe Text
a} :: Task)

-- | The attributes of the task
task_attributes :: Lens.Lens' Task (Prelude.Maybe [Attribute])
task_attributes :: (Maybe [Attribute] -> f (Maybe [Attribute])) -> Task -> f Task
task_attributes = (Task -> Maybe [Attribute])
-> (Task -> Maybe [Attribute] -> Task)
-> Lens Task Task (Maybe [Attribute]) (Maybe [Attribute])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe [Attribute]
attributes :: Maybe [Attribute]
$sel:attributes:Task' :: Task -> Maybe [Attribute]
attributes} -> Maybe [Attribute]
attributes) (\s :: Task
s@Task' {} Maybe [Attribute]
a -> Task
s {$sel:attributes:Task' :: Maybe [Attribute]
attributes = Maybe [Attribute]
a} :: Task) ((Maybe [Attribute] -> f (Maybe [Attribute])) -> Task -> f Task)
-> ((Maybe [Attribute] -> f (Maybe [Attribute]))
    -> Maybe [Attribute] -> f (Maybe [Attribute]))
-> (Maybe [Attribute] -> f (Maybe [Attribute]))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Attribute] [Attribute] [Attribute] [Attribute]
-> Iso
     (Maybe [Attribute])
     (Maybe [Attribute])
     (Maybe [Attribute])
     (Maybe [Attribute])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Attribute] [Attribute] [Attribute] [Attribute]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The version counter for the task. Every time a task experiences a change
-- that triggers a CloudWatch event, the version counter is incremented. If
-- you are replicating your Amazon ECS task state with CloudWatch Events,
-- you can compare the version of a task reported by the Amazon ECS API
-- actions with the version reported in CloudWatch Events for the task
-- (inside the @detail@ object) to verify that the version in your event
-- stream is current.
task_version :: Lens.Lens' Task (Prelude.Maybe Prelude.Integer)
task_version :: (Maybe Integer -> f (Maybe Integer)) -> Task -> f Task
task_version = (Task -> Maybe Integer)
-> (Task -> Maybe Integer -> Task)
-> Lens Task Task (Maybe Integer) (Maybe Integer)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Integer
version :: Maybe Integer
$sel:version:Task' :: Task -> Maybe Integer
version} -> Maybe Integer
version) (\s :: Task
s@Task' {} Maybe Integer
a -> Task
s {$sel:version:Task' :: Maybe Integer
version = Maybe Integer
a} :: Task)

-- | The capacity provider associated with the task.
task_capacityProviderName :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_capacityProviderName :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_capacityProviderName = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
capacityProviderName :: Maybe Text
$sel:capacityProviderName:Task' :: Task -> Maybe Text
capacityProviderName} -> Maybe Text
capacityProviderName) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:capacityProviderName:Task' :: Maybe Text
capacityProviderName = Maybe Text
a} :: Task)

-- | The tag specified when a task is started. If the task is started by an
-- Amazon ECS service, then the @startedBy@ parameter contains the
-- deployment ID of the service that starts it.
task_startedBy :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_startedBy :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_startedBy = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
startedBy :: Maybe Text
$sel:startedBy:Task' :: Task -> Maybe Text
startedBy} -> Maybe Text
startedBy) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:startedBy:Task' :: Maybe Text
startedBy = Maybe Text
a} :: Task)

-- | The reason that the task was stopped.
task_stoppedReason :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_stoppedReason :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_stoppedReason = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
stoppedReason :: Maybe Text
$sel:stoppedReason:Task' :: Task -> Maybe Text
stoppedReason} -> Maybe Text
stoppedReason) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:stoppedReason:Task' :: Maybe Text
stoppedReason = Maybe Text
a} :: Task)

-- | The connectivity status of a task.
task_connectivity :: Lens.Lens' Task (Prelude.Maybe Connectivity)
task_connectivity :: (Maybe Connectivity -> f (Maybe Connectivity)) -> Task -> f Task
task_connectivity = (Task -> Maybe Connectivity)
-> (Task -> Maybe Connectivity -> Task)
-> Lens Task Task (Maybe Connectivity) (Maybe Connectivity)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Connectivity
connectivity :: Maybe Connectivity
$sel:connectivity:Task' :: Task -> Maybe Connectivity
connectivity} -> Maybe Connectivity
connectivity) (\s :: Task
s@Task' {} Maybe Connectivity
a -> Task
s {$sel:connectivity:Task' :: Maybe Connectivity
connectivity = Maybe Connectivity
a} :: Task)

-- | The Unix timestamp for when the task stops (transitions from the
-- @RUNNING@ state to @STOPPED@).
task_stoppingAt :: Lens.Lens' Task (Prelude.Maybe Prelude.UTCTime)
task_stoppingAt :: (Maybe UTCTime -> f (Maybe UTCTime)) -> Task -> f Task
task_stoppingAt = (Task -> Maybe POSIX)
-> (Task -> Maybe POSIX -> Task)
-> Lens Task Task (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe POSIX
stoppingAt :: Maybe POSIX
$sel:stoppingAt:Task' :: Task -> Maybe POSIX
stoppingAt} -> Maybe POSIX
stoppingAt) (\s :: Task
s@Task' {} Maybe POSIX
a -> Task
s {$sel:stoppingAt:Task' :: Maybe POSIX
stoppingAt = Maybe POSIX
a} :: Task) ((Maybe POSIX -> f (Maybe POSIX)) -> Task -> f Task)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The infrastructure on which your task is running. For more information,
-- see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html Amazon ECS launch types>
-- in the /Amazon Elastic Container Service Developer Guide/.
task_launchType :: Lens.Lens' Task (Prelude.Maybe LaunchType)
task_launchType :: (Maybe LaunchType -> f (Maybe LaunchType)) -> Task -> f Task
task_launchType = (Task -> Maybe LaunchType)
-> (Task -> Maybe LaunchType -> Task)
-> Lens Task Task (Maybe LaunchType) (Maybe LaunchType)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe LaunchType
launchType :: Maybe LaunchType
$sel:launchType:Task' :: Task -> Maybe LaunchType
launchType} -> Maybe LaunchType
launchType) (\s :: Task
s@Task' {} Maybe LaunchType
a -> Task
s {$sel:launchType:Task' :: Maybe LaunchType
launchType = Maybe LaunchType
a} :: Task)

-- | The ARN of the task definition that creates the task.
task_taskDefinitionArn :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_taskDefinitionArn :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_taskDefinitionArn = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
taskDefinitionArn :: Maybe Text
$sel:taskDefinitionArn:Task' :: Task -> Maybe Text
taskDefinitionArn} -> Maybe Text
taskDefinitionArn) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:taskDefinitionArn:Task' :: Maybe Text
taskDefinitionArn = Maybe Text
a} :: Task)

-- | The health status for the task, which is determined by the health of the
-- essential containers in the task. If all essential containers in the
-- task are reporting as @HEALTHY@, then the task status also reports as
-- @HEALTHY@. If any essential containers in the task are reporting as
-- @UNHEALTHY@ or @UNKNOWN@, then the task status also reports as
-- @UNHEALTHY@ or @UNKNOWN@, accordingly.
--
-- The Amazon ECS container agent does not monitor or report on Docker
-- health checks that are embedded in a container image (such as those
-- specified in a parent image or from the image\'s Dockerfile) and not
-- specified in the container definition. Health check parameters that are
-- specified in a container definition override any Docker health checks
-- that exist in the container image.
task_healthStatus :: Lens.Lens' Task (Prelude.Maybe HealthStatus)
task_healthStatus :: (Maybe HealthStatus -> f (Maybe HealthStatus)) -> Task -> f Task
task_healthStatus = (Task -> Maybe HealthStatus)
-> (Task -> Maybe HealthStatus -> Task)
-> Lens Task Task (Maybe HealthStatus) (Maybe HealthStatus)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe HealthStatus
healthStatus :: Maybe HealthStatus
$sel:healthStatus:Task' :: Task -> Maybe HealthStatus
healthStatus} -> Maybe HealthStatus
healthStatus) (\s :: Task
s@Task' {} Maybe HealthStatus
a -> Task
s {$sel:healthStatus:Task' :: Maybe HealthStatus
healthStatus = Maybe HealthStatus
a} :: Task)

-- | The Unix timestamp for when the task last went into @CONNECTED@ status.
task_connectivityAt :: Lens.Lens' Task (Prelude.Maybe Prelude.UTCTime)
task_connectivityAt :: (Maybe UTCTime -> f (Maybe UTCTime)) -> Task -> f Task
task_connectivityAt = (Task -> Maybe POSIX)
-> (Task -> Maybe POSIX -> Task)
-> Lens Task Task (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe POSIX
connectivityAt :: Maybe POSIX
$sel:connectivityAt:Task' :: Task -> Maybe POSIX
connectivityAt} -> Maybe POSIX
connectivityAt) (\s :: Task
s@Task' {} Maybe POSIX
a -> Task
s {$sel:connectivityAt:Task' :: Maybe POSIX
connectivityAt = Maybe POSIX
a} :: Task) ((Maybe POSIX -> f (Maybe POSIX)) -> Task -> f Task)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The number of CPU units used by the task as expressed in a task
-- definition. It can be expressed as an integer using CPU units, for
-- example @1024@. It can also be expressed as a string using vCPUs, for
-- example @1 vCPU@ or @1 vcpu@. String values are converted to an integer
-- indicating the CPU units when the task definition is registered.
--
-- If you are using the EC2 launch type, this field is optional. Supported
-- values are between @128@ CPU units (@0.125@ vCPUs) and @10240@ CPU units
-- (@10@ vCPUs).
--
-- If you are using the Fargate launch type, this field is required and you
-- must use one of the following values, which determines your range of
-- supported values for the @memory@ parameter:
--
-- -   256 (.25 vCPU) - Available @memory@ values: 512 (0.5 GB), 1024 (1
--     GB), 2048 (2 GB)
--
-- -   512 (.5 vCPU) - Available @memory@ values: 1024 (1 GB), 2048 (2 GB),
--     3072 (3 GB), 4096 (4 GB)
--
-- -   1024 (1 vCPU) - Available @memory@ values: 2048 (2 GB), 3072 (3 GB),
--     4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)
--
-- -   2048 (2 vCPU) - Available @memory@ values: Between 4096 (4 GB) and
--     16384 (16 GB) in increments of 1024 (1 GB)
--
-- -   4096 (4 vCPU) - Available @memory@ values: Between 8192 (8 GB) and
--     30720 (30 GB) in increments of 1024 (1 GB)
task_cpu :: Lens.Lens' Task (Prelude.Maybe Prelude.Text)
task_cpu :: (Maybe Text -> f (Maybe Text)) -> Task -> f Task
task_cpu = (Task -> Maybe Text)
-> (Task -> Maybe Text -> Task)
-> Lens Task Task (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Text
cpu :: Maybe Text
$sel:cpu:Task' :: Task -> Maybe Text
cpu} -> Maybe Text
cpu) (\s :: Task
s@Task' {} Maybe Text
a -> Task
s {$sel:cpu:Task' :: Maybe Text
cpu = Maybe Text
a} :: Task)

-- | Whether or not execute command functionality is enabled for this task.
-- If @true@, this enables execute command functionality on all containers
-- in the task.
task_enableExecuteCommand :: Lens.Lens' Task (Prelude.Maybe Prelude.Bool)
task_enableExecuteCommand :: (Maybe Bool -> f (Maybe Bool)) -> Task -> f Task
task_enableExecuteCommand = (Task -> Maybe Bool)
-> (Task -> Maybe Bool -> Task)
-> Lens Task Task (Maybe Bool) (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe Bool
enableExecuteCommand :: Maybe Bool
$sel:enableExecuteCommand:Task' :: Task -> Maybe Bool
enableExecuteCommand} -> Maybe Bool
enableExecuteCommand) (\s :: Task
s@Task' {} Maybe Bool
a -> Task
s {$sel:enableExecuteCommand:Task' :: Maybe Bool
enableExecuteCommand = Maybe Bool
a} :: Task)

-- | The Unix timestamp for when the container image pull began.
task_pullStartedAt :: Lens.Lens' Task (Prelude.Maybe Prelude.UTCTime)
task_pullStartedAt :: (Maybe UTCTime -> f (Maybe UTCTime)) -> Task -> f Task
task_pullStartedAt = (Task -> Maybe POSIX)
-> (Task -> Maybe POSIX -> Task)
-> Lens Task Task (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe POSIX
pullStartedAt :: Maybe POSIX
$sel:pullStartedAt:Task' :: Task -> Maybe POSIX
pullStartedAt} -> Maybe POSIX
pullStartedAt) (\s :: Task
s@Task' {} Maybe POSIX
a -> Task
s {$sel:pullStartedAt:Task' :: Maybe POSIX
pullStartedAt = Maybe POSIX
a} :: Task) ((Maybe POSIX -> f (Maybe POSIX)) -> Task -> f Task)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The metadata that you apply to the task to help you categorize and
-- organize them. Each tag consists of a key and an optional value, both of
-- which you define.
--
-- The following basic restrictions apply to tags:
--
-- -   Maximum number of tags per resource - 50
--
-- -   For each resource, each tag key must be unique, and each tag key can
--     have only one value.
--
-- -   Maximum key length - 128 Unicode characters in UTF-8
--
-- -   Maximum value length - 256 Unicode characters in UTF-8
--
-- -   If your tagging schema is used across multiple services and
--     resources, remember that other services may have restrictions on
--     allowed characters. Generally allowed characters are: letters,
--     numbers, and spaces representable in UTF-8, and the following
--     characters: + - = . _ : \/ \@.
--
-- -   Tag keys and values are case-sensitive.
--
-- -   Do not use @aws:@, @AWS:@, or any upper or lowercase combination of
--     such as a prefix for either keys or values as it is reserved for
--     Amazon Web Services use. You cannot edit or delete tag keys or
--     values with this prefix. Tags with this prefix do not count against
--     your tags per resource limit.
task_tags :: Lens.Lens' Task (Prelude.Maybe [Tag])
task_tags :: (Maybe [Tag] -> f (Maybe [Tag])) -> Task -> f Task
task_tags = (Task -> Maybe [Tag])
-> (Task -> Maybe [Tag] -> Task)
-> Lens Task Task (Maybe [Tag]) (Maybe [Tag])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Task' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:Task' :: Task -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: Task
s@Task' {} Maybe [Tag]
a -> Task
s {$sel:tags:Task' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: Task) ((Maybe [Tag] -> f (Maybe [Tag])) -> Task -> f Task)
-> ((Maybe [Tag] -> f (Maybe [Tag]))
    -> Maybe [Tag] -> f (Maybe [Tag]))
-> (Maybe [Tag] -> f (Maybe [Tag]))
-> Task
-> f Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Tag] [Tag] [Tag] [Tag]
-> Iso (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Tag] [Tag] [Tag] [Tag]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.FromJSON Task where
  parseJSON :: Value -> Parser Task
parseJSON =
    String -> (Object -> Parser Task) -> Value -> Parser Task
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"Task"
      ( \Object
x ->
          Maybe POSIX
-> Maybe Text
-> Maybe TaskOverride
-> Maybe [InferenceAccelerator]
-> Maybe Text
-> Maybe Text
-> Maybe [Attachment]
-> Maybe POSIX
-> Maybe TaskStopCode
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe POSIX
-> Maybe EphemeralStorage
-> Maybe Text
-> Maybe Text
-> Maybe POSIX
-> Maybe [Container]
-> Maybe POSIX
-> Maybe Text
-> Maybe [Attribute]
-> Maybe Integer
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Connectivity
-> Maybe POSIX
-> Maybe LaunchType
-> Maybe Text
-> Maybe HealthStatus
-> Maybe POSIX
-> Maybe Text
-> Maybe Bool
-> Maybe POSIX
-> Maybe [Tag]
-> Task
Task'
            (Maybe POSIX
 -> Maybe Text
 -> Maybe TaskOverride
 -> Maybe [InferenceAccelerator]
 -> Maybe Text
 -> Maybe Text
 -> Maybe [Attachment]
 -> Maybe POSIX
 -> Maybe TaskStopCode
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe POSIX
 -> Maybe EphemeralStorage
 -> Maybe Text
 -> Maybe Text
 -> Maybe POSIX
 -> Maybe [Container]
 -> Maybe POSIX
 -> Maybe Text
 -> Maybe [Attribute]
 -> Maybe Integer
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Connectivity
 -> Maybe POSIX
 -> Maybe LaunchType
 -> Maybe Text
 -> Maybe HealthStatus
 -> Maybe POSIX
 -> Maybe Text
 -> Maybe Bool
 -> Maybe POSIX
 -> Maybe [Tag]
 -> Task)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe Text
      -> Maybe TaskOverride
      -> Maybe [InferenceAccelerator]
      -> Maybe Text
      -> Maybe Text
      -> Maybe [Attachment]
      -> Maybe POSIX
      -> Maybe TaskStopCode
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"stoppedAt")
            Parser
  (Maybe Text
   -> Maybe TaskOverride
   -> Maybe [InferenceAccelerator]
   -> Maybe Text
   -> Maybe Text
   -> Maybe [Attachment]
   -> Maybe POSIX
   -> Maybe TaskStopCode
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe TaskOverride
      -> Maybe [InferenceAccelerator]
      -> Maybe Text
      -> Maybe Text
      -> Maybe [Attachment]
      -> Maybe POSIX
      -> Maybe TaskStopCode
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"desiredStatus")
            Parser
  (Maybe TaskOverride
   -> Maybe [InferenceAccelerator]
   -> Maybe Text
   -> Maybe Text
   -> Maybe [Attachment]
   -> Maybe POSIX
   -> Maybe TaskStopCode
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe TaskOverride)
-> Parser
     (Maybe [InferenceAccelerator]
      -> Maybe Text
      -> Maybe Text
      -> Maybe [Attachment]
      -> Maybe POSIX
      -> Maybe TaskStopCode
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe TaskOverride)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"overrides")
            Parser
  (Maybe [InferenceAccelerator]
   -> Maybe Text
   -> Maybe Text
   -> Maybe [Attachment]
   -> Maybe POSIX
   -> Maybe TaskStopCode
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe [InferenceAccelerator])
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe [Attachment]
      -> Maybe POSIX
      -> Maybe TaskStopCode
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [InferenceAccelerator]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"inferenceAccelerators"
                            Parser (Maybe (Maybe [InferenceAccelerator]))
-> Maybe [InferenceAccelerator]
-> Parser (Maybe [InferenceAccelerator])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [InferenceAccelerator]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe [Attachment]
   -> Maybe POSIX
   -> Maybe TaskStopCode
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe [Attachment]
      -> Maybe POSIX
      -> Maybe TaskStopCode
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"clusterArn")
            Parser
  (Maybe Text
   -> Maybe [Attachment]
   -> Maybe POSIX
   -> Maybe TaskStopCode
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe [Attachment]
      -> Maybe POSIX
      -> Maybe TaskStopCode
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"group")
            Parser
  (Maybe [Attachment]
   -> Maybe POSIX
   -> Maybe TaskStopCode
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe [Attachment])
-> Parser
     (Maybe POSIX
      -> Maybe TaskStopCode
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [Attachment]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"attachments" Parser (Maybe (Maybe [Attachment]))
-> Maybe [Attachment] -> Parser (Maybe [Attachment])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [Attachment]
forall a. Monoid a => a
Prelude.mempty)
            Parser
  (Maybe POSIX
   -> Maybe TaskStopCode
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe TaskStopCode
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"createdAt")
            Parser
  (Maybe TaskStopCode
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe TaskStopCode)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe TaskStopCode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"stopCode")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"platformVersion")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"taskArn")
            Parser
  (Maybe Text
   -> Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe POSIX
      -> Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"containerInstanceArn")
            Parser
  (Maybe POSIX
   -> Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe EphemeralStorage
      -> Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"executionStoppedAt")
            Parser
  (Maybe EphemeralStorage
   -> Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe EphemeralStorage)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe EphemeralStorage)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"ephemeralStorage")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"lastStatus")
            Parser
  (Maybe Text
   -> Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe POSIX
      -> Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"memory")
            Parser
  (Maybe POSIX
   -> Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe [Container]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"pullStoppedAt")
            Parser
  (Maybe [Container]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe [Container])
-> Parser
     (Maybe POSIX
      -> Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [Container]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"containers" Parser (Maybe (Maybe [Container]))
-> Maybe [Container] -> Parser (Maybe [Container])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [Container]
forall a. Monoid a => a
Prelude.mempty)
            Parser
  (Maybe POSIX
   -> Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe Text
      -> Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"startedAt")
            Parser
  (Maybe Text
   -> Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe [Attribute]
      -> Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"availabilityZone")
            Parser
  (Maybe [Attribute]
   -> Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe [Attribute])
-> Parser
     (Maybe Integer
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [Attribute]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"attributes" Parser (Maybe (Maybe [Attribute]))
-> Maybe [Attribute] -> Parser (Maybe [Attribute])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [Attribute]
forall a. Monoid a => a
Prelude.mempty)
            Parser
  (Maybe Integer
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Integer)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Integer)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"version")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"capacityProviderName")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"startedBy")
            Parser
  (Maybe Text
   -> Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe Connectivity
      -> Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"stoppedReason")
            Parser
  (Maybe Connectivity
   -> Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Connectivity)
-> Parser
     (Maybe POSIX
      -> Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Connectivity)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"connectivity")
            Parser
  (Maybe POSIX
   -> Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe LaunchType
      -> Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"stoppingAt")
            Parser
  (Maybe LaunchType
   -> Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe LaunchType)
-> Parser
     (Maybe Text
      -> Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe LaunchType)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"launchType")
            Parser
  (Maybe Text
   -> Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe Text)
-> Parser
     (Maybe HealthStatus
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Bool
      -> Maybe POSIX
      -> Maybe [Tag]
      -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"taskDefinitionArn")
            Parser
  (Maybe HealthStatus
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Bool
   -> Maybe POSIX
   -> Maybe [Tag]
   -> Task)
-> Parser (Maybe HealthStatus)
-> Parser
     (Maybe POSIX
      -> Maybe Text -> Maybe Bool -> Maybe POSIX -> Maybe [Tag] -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe HealthStatus)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"healthStatus")
            Parser
  (Maybe POSIX
   -> Maybe Text -> Maybe Bool -> Maybe POSIX -> Maybe [Tag] -> Task)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe Text -> Maybe Bool -> Maybe POSIX -> Maybe [Tag] -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"connectivityAt")
            Parser
  (Maybe Text -> Maybe Bool -> Maybe POSIX -> Maybe [Tag] -> Task)
-> Parser (Maybe Text)
-> Parser (Maybe Bool -> Maybe POSIX -> Maybe [Tag] -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"cpu")
            Parser (Maybe Bool -> Maybe POSIX -> Maybe [Tag] -> Task)
-> Parser (Maybe Bool)
-> Parser (Maybe POSIX -> Maybe [Tag] -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"enableExecuteCommand")
            Parser (Maybe POSIX -> Maybe [Tag] -> Task)
-> Parser (Maybe POSIX) -> Parser (Maybe [Tag] -> Task)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"pullStartedAt")
            Parser (Maybe [Tag] -> Task) -> Parser (Maybe [Tag]) -> Parser Task
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [Tag]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"tags" Parser (Maybe (Maybe [Tag])) -> Maybe [Tag] -> Parser (Maybe [Tag])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [Tag]
forall a. Monoid a => a
Prelude.mempty)
      )

instance Prelude.Hashable Task

instance Prelude.NFData Task