{-# 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.DynamoDB.Types.ExpectedAttributeValue
-- 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.DynamoDB.Types.ExpectedAttributeValue where

import qualified Amazonka.Core as Core
import Amazonka.DynamoDB.Types.AttributeValue
import Amazonka.DynamoDB.Types.ComparisonOperator
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude

-- | Represents a condition to be compared with an attribute value. This
-- condition can be used with @DeleteItem@, @PutItem@, or @UpdateItem@
-- operations; if the comparison evaluates to true, the operation succeeds;
-- if not, the operation fails. You can use @ExpectedAttributeValue@ in one
-- of two different ways:
--
-- -   Use @AttributeValueList@ to specify one or more values to compare
--     against an attribute. Use @ComparisonOperator@ to specify how you
--     want to perform the comparison. If the comparison evaluates to true,
--     then the conditional operation succeeds.
--
-- -   Use @Value@ to specify a value that DynamoDB will compare against an
--     attribute. If the values match, then @ExpectedAttributeValue@
--     evaluates to true and the conditional operation succeeds.
--     Optionally, you can also set @Exists@ to false, indicating that you
--     /do not/ expect to find the attribute value in the table. In this
--     case, the conditional operation succeeds only if the comparison
--     evaluates to false.
--
-- @Value@ and @Exists@ are incompatible with @AttributeValueList@ and
-- @ComparisonOperator@. Note that if you use both sets of parameters at
-- once, DynamoDB will return a @ValidationException@ exception.
--
-- /See:/ 'newExpectedAttributeValue' smart constructor.
data ExpectedAttributeValue = ExpectedAttributeValue'
  { -- | One or more values to evaluate against the supplied attribute. The
    -- number of values in the list depends on the @ComparisonOperator@ being
    -- used.
    --
    -- For type Number, value comparisons are numeric.
    --
    -- String value comparisons for greater than, equals, or less than are
    -- based on ASCII character code values. For example, @a@ is greater than
    -- @A@, and @a@ is greater than @B@. For a list of code values, see
    -- <http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters>.
    --
    -- For Binary, DynamoDB treats each byte of the binary data as unsigned
    -- when it compares binary values.
    --
    -- For information on specifying data types in JSON, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataFormat.html JSON Data Format>
    -- in the /Amazon DynamoDB Developer Guide/.
    ExpectedAttributeValue -> Maybe [AttributeValue]
attributeValueList :: Prelude.Maybe [AttributeValue],
    -- | Causes DynamoDB to evaluate the value before attempting a conditional
    -- operation:
    --
    -- -   If @Exists@ is @true@, DynamoDB will check to see if that attribute
    --     value already exists in the table. If it is found, then the
    --     operation succeeds. If it is not found, the operation fails with a
    --     @ConditionCheckFailedException@.
    --
    -- -   If @Exists@ is @false@, DynamoDB assumes that the attribute value
    --     does not exist in the table. If in fact the value does not exist,
    --     then the assumption is valid and the operation succeeds. If the
    --     value is found, despite the assumption that it does not exist, the
    --     operation fails with a @ConditionCheckFailedException@.
    --
    -- The default setting for @Exists@ is @true@. If you supply a @Value@ all
    -- by itself, DynamoDB assumes the attribute exists: You don\'t have to set
    -- @Exists@ to @true@, because it is implied.
    --
    -- DynamoDB returns a @ValidationException@ if:
    --
    -- -   @Exists@ is @true@ but there is no @Value@ to check. (You expect a
    --     value to exist, but don\'t specify what that value is.)
    --
    -- -   @Exists@ is @false@ but you also provide a @Value@. (You cannot
    --     expect an attribute to have a value, while also expecting it not to
    --     exist.)
    ExpectedAttributeValue -> Maybe Bool
exists :: Prelude.Maybe Prelude.Bool,
    -- | Represents the data for the expected attribute.
    --
    -- Each attribute value is described as a name-value pair. The name is the
    -- data type, and the value is the data itself.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes Data Types>
    -- in the /Amazon DynamoDB Developer Guide/.
    ExpectedAttributeValue -> Maybe AttributeValue
value :: Prelude.Maybe AttributeValue,
    -- | A comparator for evaluating attributes in the @AttributeValueList@. For
    -- example, equals, greater than, less than, etc.
    --
    -- The following comparison operators are available:
    --
    -- @EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN@
    --
    -- The following are descriptions of each comparison operator.
    --
    -- -   @EQ@ : Equal. @EQ@ is supported for all data types, including lists
    --     and maps.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, Binary, String Set, Number Set, or Binary
    --     Set. If an item contains an @AttributeValue@ element of a different
    --     type than the one provided in the request, the value does not match.
    --     For example, @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @NE@ : Not equal. @NE@ is supported for all data types, including
    --     lists and maps.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ of type
    --     String, Number, Binary, String Set, Number Set, or Binary Set. If an
    --     item contains an @AttributeValue@ of a different type than the one
    --     provided in the request, the value does not match. For example,
    --     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @LE@ : Less than or equal.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, or Binary (not a set type). If an item
    --     contains an @AttributeValue@ element of a different type than the
    --     one provided in the request, the value does not match. For example,
    --     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not compare to
    --     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @LT@ : Less than.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ of type
    --     String, Number, or Binary (not a set type). If an item contains an
    --     @AttributeValue@ element of a different type than the one provided
    --     in the request, the value does not match. For example,
    --     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not compare to
    --     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @GE@ : Greater than or equal.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, or Binary (not a set type). If an item
    --     contains an @AttributeValue@ element of a different type than the
    --     one provided in the request, the value does not match. For example,
    --     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not compare to
    --     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @GT@ : Greater than.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, or Binary (not a set type). If an item
    --     contains an @AttributeValue@ element of a different type than the
    --     one provided in the request, the value does not match. For example,
    --     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not compare to
    --     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @NOT_NULL@ : The attribute exists. @NOT_NULL@ is supported for all
    --     data types, including lists and maps.
    --
    --     This operator tests for the existence of an attribute, not its data
    --     type. If the data type of attribute \"@a@\" is null, and you
    --     evaluate it using @NOT_NULL@, the result is a Boolean @true@. This
    --     result is because the attribute \"@a@\" exists; its data type is not
    --     relevant to the @NOT_NULL@ comparison operator.
    --
    -- -   @NULL@ : The attribute does not exist. @NULL@ is supported for all
    --     data types, including lists and maps.
    --
    --     This operator tests for the nonexistence of an attribute, not its
    --     data type. If the data type of attribute \"@a@\" is null, and you
    --     evaluate it using @NULL@, the result is a Boolean @false@. This is
    --     because the attribute \"@a@\" exists; its data type is not relevant
    --     to the @NULL@ comparison operator.
    --
    -- -   @CONTAINS@ : Checks for a subsequence, or value in a set.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, or Binary (not a set type). If the target
    --     attribute of the comparison is of type String, then the operator
    --     checks for a substring match. If the target attribute of the
    --     comparison is of type Binary, then the operator looks for a
    --     subsequence of the target that matches the input. If the target
    --     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
    --     \"@BS@\"), then the operator evaluates to true if it finds an exact
    --     match with any member of the set.
    --
    --     CONTAINS is supported for lists: When evaluating \"@a CONTAINS b@\",
    --     \"@a@\" can be a list; however, \"@b@\" cannot be a set, a map, or a
    --     list.
    --
    -- -   @NOT_CONTAINS@ : Checks for absence of a subsequence, or absence of
    --     a value in a set.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, or Binary (not a set type). If the target
    --     attribute of the comparison is a String, then the operator checks
    --     for the absence of a substring match. If the target attribute of the
    --     comparison is Binary, then the operator checks for the absence of a
    --     subsequence of the target that matches the input. If the target
    --     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
    --     \"@BS@\"), then the operator evaluates to true if it /does not/ find
    --     an exact match with any member of the set.
    --
    --     NOT_CONTAINS is supported for lists: When evaluating
    --     \"@a NOT CONTAINS b@\", \"@a@\" can be a list; however, \"@b@\"
    --     cannot be a set, a map, or a list.
    --
    -- -   @BEGINS_WITH@ : Checks for a prefix.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ of type
    --     String or Binary (not a Number or a set type). The target attribute
    --     of the comparison must be of type String or Binary (not a Number or
    --     a set type).
    --
    -- -   @IN@ : Checks for matching elements in a list.
    --
    --     @AttributeValueList@ can contain one or more @AttributeValue@
    --     elements of type String, Number, or Binary. These attributes are
    --     compared against an existing attribute of an item. If any elements
    --     of the input are equal to the item attribute, the expression
    --     evaluates to true.
    --
    -- -   @BETWEEN@ : Greater than or equal to the first value, and less than
    --     or equal to the second value.
    --
    --     @AttributeValueList@ must contain two @AttributeValue@ elements of
    --     the same type, either String, Number, or Binary (not a set type). A
    --     target attribute matches if the target value is greater than, or
    --     equal to, the first element and less than, or equal to, the second
    --     element. If an item contains an @AttributeValue@ element of a
    --     different type than the one provided in the request, the value does
    --     not match. For example, @{\"S\":\"6\"}@ does not compare to
    --     @{\"N\":\"6\"}@. Also, @{\"N\":\"6\"}@ does not compare to
    --     @{\"NS\":[\"6\", \"2\", \"1\"]}@
    ExpectedAttributeValue -> Maybe ComparisonOperator
comparisonOperator :: Prelude.Maybe ComparisonOperator
  }
  deriving (ExpectedAttributeValue -> ExpectedAttributeValue -> Bool
(ExpectedAttributeValue -> ExpectedAttributeValue -> Bool)
-> (ExpectedAttributeValue -> ExpectedAttributeValue -> Bool)
-> Eq ExpectedAttributeValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExpectedAttributeValue -> ExpectedAttributeValue -> Bool
$c/= :: ExpectedAttributeValue -> ExpectedAttributeValue -> Bool
== :: ExpectedAttributeValue -> ExpectedAttributeValue -> Bool
$c== :: ExpectedAttributeValue -> ExpectedAttributeValue -> Bool
Prelude.Eq, ReadPrec [ExpectedAttributeValue]
ReadPrec ExpectedAttributeValue
Int -> ReadS ExpectedAttributeValue
ReadS [ExpectedAttributeValue]
(Int -> ReadS ExpectedAttributeValue)
-> ReadS [ExpectedAttributeValue]
-> ReadPrec ExpectedAttributeValue
-> ReadPrec [ExpectedAttributeValue]
-> Read ExpectedAttributeValue
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ExpectedAttributeValue]
$creadListPrec :: ReadPrec [ExpectedAttributeValue]
readPrec :: ReadPrec ExpectedAttributeValue
$creadPrec :: ReadPrec ExpectedAttributeValue
readList :: ReadS [ExpectedAttributeValue]
$creadList :: ReadS [ExpectedAttributeValue]
readsPrec :: Int -> ReadS ExpectedAttributeValue
$creadsPrec :: Int -> ReadS ExpectedAttributeValue
Prelude.Read, Int -> ExpectedAttributeValue -> ShowS
[ExpectedAttributeValue] -> ShowS
ExpectedAttributeValue -> String
(Int -> ExpectedAttributeValue -> ShowS)
-> (ExpectedAttributeValue -> String)
-> ([ExpectedAttributeValue] -> ShowS)
-> Show ExpectedAttributeValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExpectedAttributeValue] -> ShowS
$cshowList :: [ExpectedAttributeValue] -> ShowS
show :: ExpectedAttributeValue -> String
$cshow :: ExpectedAttributeValue -> String
showsPrec :: Int -> ExpectedAttributeValue -> ShowS
$cshowsPrec :: Int -> ExpectedAttributeValue -> ShowS
Prelude.Show, (forall x. ExpectedAttributeValue -> Rep ExpectedAttributeValue x)
-> (forall x.
    Rep ExpectedAttributeValue x -> ExpectedAttributeValue)
-> Generic ExpectedAttributeValue
forall x. Rep ExpectedAttributeValue x -> ExpectedAttributeValue
forall x. ExpectedAttributeValue -> Rep ExpectedAttributeValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ExpectedAttributeValue x -> ExpectedAttributeValue
$cfrom :: forall x. ExpectedAttributeValue -> Rep ExpectedAttributeValue x
Prelude.Generic)

-- |
-- Create a value of 'ExpectedAttributeValue' 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:
--
-- 'attributeValueList', 'expectedAttributeValue_attributeValueList' - One or more values to evaluate against the supplied attribute. The
-- number of values in the list depends on the @ComparisonOperator@ being
-- used.
--
-- For type Number, value comparisons are numeric.
--
-- String value comparisons for greater than, equals, or less than are
-- based on ASCII character code values. For example, @a@ is greater than
-- @A@, and @a@ is greater than @B@. For a list of code values, see
-- <http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters>.
--
-- For Binary, DynamoDB treats each byte of the binary data as unsigned
-- when it compares binary values.
--
-- For information on specifying data types in JSON, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataFormat.html JSON Data Format>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'exists', 'expectedAttributeValue_exists' - Causes DynamoDB to evaluate the value before attempting a conditional
-- operation:
--
-- -   If @Exists@ is @true@, DynamoDB will check to see if that attribute
--     value already exists in the table. If it is found, then the
--     operation succeeds. If it is not found, the operation fails with a
--     @ConditionCheckFailedException@.
--
-- -   If @Exists@ is @false@, DynamoDB assumes that the attribute value
--     does not exist in the table. If in fact the value does not exist,
--     then the assumption is valid and the operation succeeds. If the
--     value is found, despite the assumption that it does not exist, the
--     operation fails with a @ConditionCheckFailedException@.
--
-- The default setting for @Exists@ is @true@. If you supply a @Value@ all
-- by itself, DynamoDB assumes the attribute exists: You don\'t have to set
-- @Exists@ to @true@, because it is implied.
--
-- DynamoDB returns a @ValidationException@ if:
--
-- -   @Exists@ is @true@ but there is no @Value@ to check. (You expect a
--     value to exist, but don\'t specify what that value is.)
--
-- -   @Exists@ is @false@ but you also provide a @Value@. (You cannot
--     expect an attribute to have a value, while also expecting it not to
--     exist.)
--
-- 'value', 'expectedAttributeValue_value' - Represents the data for the expected attribute.
--
-- Each attribute value is described as a name-value pair. The name is the
-- data type, and the value is the data itself.
--
-- For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes Data Types>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'comparisonOperator', 'expectedAttributeValue_comparisonOperator' - A comparator for evaluating attributes in the @AttributeValueList@. For
-- example, equals, greater than, less than, etc.
--
-- The following comparison operators are available:
--
-- @EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN@
--
-- The following are descriptions of each comparison operator.
--
-- -   @EQ@ : Equal. @EQ@ is supported for all data types, including lists
--     and maps.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, Binary, String Set, Number Set, or Binary
--     Set. If an item contains an @AttributeValue@ element of a different
--     type than the one provided in the request, the value does not match.
--     For example, @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @NE@ : Not equal. @NE@ is supported for all data types, including
--     lists and maps.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String, Number, Binary, String Set, Number Set, or Binary Set. If an
--     item contains an @AttributeValue@ of a different type than the one
--     provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @LE@ : Less than or equal.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @LT@ : Less than.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String, Number, or Binary (not a set type). If an item contains an
--     @AttributeValue@ element of a different type than the one provided
--     in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @GE@ : Greater than or equal.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @GT@ : Greater than.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @NOT_NULL@ : The attribute exists. @NOT_NULL@ is supported for all
--     data types, including lists and maps.
--
--     This operator tests for the existence of an attribute, not its data
--     type. If the data type of attribute \"@a@\" is null, and you
--     evaluate it using @NOT_NULL@, the result is a Boolean @true@. This
--     result is because the attribute \"@a@\" exists; its data type is not
--     relevant to the @NOT_NULL@ comparison operator.
--
-- -   @NULL@ : The attribute does not exist. @NULL@ is supported for all
--     data types, including lists and maps.
--
--     This operator tests for the nonexistence of an attribute, not its
--     data type. If the data type of attribute \"@a@\" is null, and you
--     evaluate it using @NULL@, the result is a Boolean @false@. This is
--     because the attribute \"@a@\" exists; its data type is not relevant
--     to the @NULL@ comparison operator.
--
-- -   @CONTAINS@ : Checks for a subsequence, or value in a set.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If the target
--     attribute of the comparison is of type String, then the operator
--     checks for a substring match. If the target attribute of the
--     comparison is of type Binary, then the operator looks for a
--     subsequence of the target that matches the input. If the target
--     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
--     \"@BS@\"), then the operator evaluates to true if it finds an exact
--     match with any member of the set.
--
--     CONTAINS is supported for lists: When evaluating \"@a CONTAINS b@\",
--     \"@a@\" can be a list; however, \"@b@\" cannot be a set, a map, or a
--     list.
--
-- -   @NOT_CONTAINS@ : Checks for absence of a subsequence, or absence of
--     a value in a set.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If the target
--     attribute of the comparison is a String, then the operator checks
--     for the absence of a substring match. If the target attribute of the
--     comparison is Binary, then the operator checks for the absence of a
--     subsequence of the target that matches the input. If the target
--     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
--     \"@BS@\"), then the operator evaluates to true if it /does not/ find
--     an exact match with any member of the set.
--
--     NOT_CONTAINS is supported for lists: When evaluating
--     \"@a NOT CONTAINS b@\", \"@a@\" can be a list; however, \"@b@\"
--     cannot be a set, a map, or a list.
--
-- -   @BEGINS_WITH@ : Checks for a prefix.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String or Binary (not a Number or a set type). The target attribute
--     of the comparison must be of type String or Binary (not a Number or
--     a set type).
--
-- -   @IN@ : Checks for matching elements in a list.
--
--     @AttributeValueList@ can contain one or more @AttributeValue@
--     elements of type String, Number, or Binary. These attributes are
--     compared against an existing attribute of an item. If any elements
--     of the input are equal to the item attribute, the expression
--     evaluates to true.
--
-- -   @BETWEEN@ : Greater than or equal to the first value, and less than
--     or equal to the second value.
--
--     @AttributeValueList@ must contain two @AttributeValue@ elements of
--     the same type, either String, Number, or Binary (not a set type). A
--     target attribute matches if the target value is greater than, or
--     equal to, the first element and less than, or equal to, the second
--     element. If an item contains an @AttributeValue@ element of a
--     different type than the one provided in the request, the value does
--     not match. For example, @{\"S\":\"6\"}@ does not compare to
--     @{\"N\":\"6\"}@. Also, @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@
newExpectedAttributeValue ::
  ExpectedAttributeValue
newExpectedAttributeValue :: ExpectedAttributeValue
newExpectedAttributeValue =
  ExpectedAttributeValue' :: Maybe [AttributeValue]
-> Maybe Bool
-> Maybe AttributeValue
-> Maybe ComparisonOperator
-> ExpectedAttributeValue
ExpectedAttributeValue'
    { $sel:attributeValueList:ExpectedAttributeValue' :: Maybe [AttributeValue]
attributeValueList =
        Maybe [AttributeValue]
forall a. Maybe a
Prelude.Nothing,
      $sel:exists:ExpectedAttributeValue' :: Maybe Bool
exists = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:value:ExpectedAttributeValue' :: Maybe AttributeValue
value = Maybe AttributeValue
forall a. Maybe a
Prelude.Nothing,
      $sel:comparisonOperator:ExpectedAttributeValue' :: Maybe ComparisonOperator
comparisonOperator = Maybe ComparisonOperator
forall a. Maybe a
Prelude.Nothing
    }

-- | One or more values to evaluate against the supplied attribute. The
-- number of values in the list depends on the @ComparisonOperator@ being
-- used.
--
-- For type Number, value comparisons are numeric.
--
-- String value comparisons for greater than, equals, or less than are
-- based on ASCII character code values. For example, @a@ is greater than
-- @A@, and @a@ is greater than @B@. For a list of code values, see
-- <http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters>.
--
-- For Binary, DynamoDB treats each byte of the binary data as unsigned
-- when it compares binary values.
--
-- For information on specifying data types in JSON, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataFormat.html JSON Data Format>
-- in the /Amazon DynamoDB Developer Guide/.
expectedAttributeValue_attributeValueList :: Lens.Lens' ExpectedAttributeValue (Prelude.Maybe [AttributeValue])
expectedAttributeValue_attributeValueList :: (Maybe [AttributeValue] -> f (Maybe [AttributeValue]))
-> ExpectedAttributeValue -> f ExpectedAttributeValue
expectedAttributeValue_attributeValueList = (ExpectedAttributeValue -> Maybe [AttributeValue])
-> (ExpectedAttributeValue
    -> Maybe [AttributeValue] -> ExpectedAttributeValue)
-> Lens
     ExpectedAttributeValue
     ExpectedAttributeValue
     (Maybe [AttributeValue])
     (Maybe [AttributeValue])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExpectedAttributeValue' {Maybe [AttributeValue]
attributeValueList :: Maybe [AttributeValue]
$sel:attributeValueList:ExpectedAttributeValue' :: ExpectedAttributeValue -> Maybe [AttributeValue]
attributeValueList} -> Maybe [AttributeValue]
attributeValueList) (\s :: ExpectedAttributeValue
s@ExpectedAttributeValue' {} Maybe [AttributeValue]
a -> ExpectedAttributeValue
s {$sel:attributeValueList:ExpectedAttributeValue' :: Maybe [AttributeValue]
attributeValueList = Maybe [AttributeValue]
a} :: ExpectedAttributeValue) ((Maybe [AttributeValue] -> f (Maybe [AttributeValue]))
 -> ExpectedAttributeValue -> f ExpectedAttributeValue)
-> ((Maybe [AttributeValue] -> f (Maybe [AttributeValue]))
    -> Maybe [AttributeValue] -> f (Maybe [AttributeValue]))
-> (Maybe [AttributeValue] -> f (Maybe [AttributeValue]))
-> ExpectedAttributeValue
-> f ExpectedAttributeValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [AttributeValue] [AttributeValue] [AttributeValue] [AttributeValue]
-> Iso
     (Maybe [AttributeValue])
     (Maybe [AttributeValue])
     (Maybe [AttributeValue])
     (Maybe [AttributeValue])
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
  [AttributeValue] [AttributeValue] [AttributeValue] [AttributeValue]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Causes DynamoDB to evaluate the value before attempting a conditional
-- operation:
--
-- -   If @Exists@ is @true@, DynamoDB will check to see if that attribute
--     value already exists in the table. If it is found, then the
--     operation succeeds. If it is not found, the operation fails with a
--     @ConditionCheckFailedException@.
--
-- -   If @Exists@ is @false@, DynamoDB assumes that the attribute value
--     does not exist in the table. If in fact the value does not exist,
--     then the assumption is valid and the operation succeeds. If the
--     value is found, despite the assumption that it does not exist, the
--     operation fails with a @ConditionCheckFailedException@.
--
-- The default setting for @Exists@ is @true@. If you supply a @Value@ all
-- by itself, DynamoDB assumes the attribute exists: You don\'t have to set
-- @Exists@ to @true@, because it is implied.
--
-- DynamoDB returns a @ValidationException@ if:
--
-- -   @Exists@ is @true@ but there is no @Value@ to check. (You expect a
--     value to exist, but don\'t specify what that value is.)
--
-- -   @Exists@ is @false@ but you also provide a @Value@. (You cannot
--     expect an attribute to have a value, while also expecting it not to
--     exist.)
expectedAttributeValue_exists :: Lens.Lens' ExpectedAttributeValue (Prelude.Maybe Prelude.Bool)
expectedAttributeValue_exists :: (Maybe Bool -> f (Maybe Bool))
-> ExpectedAttributeValue -> f ExpectedAttributeValue
expectedAttributeValue_exists = (ExpectedAttributeValue -> Maybe Bool)
-> (ExpectedAttributeValue -> Maybe Bool -> ExpectedAttributeValue)
-> Lens
     ExpectedAttributeValue
     ExpectedAttributeValue
     (Maybe Bool)
     (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExpectedAttributeValue' {Maybe Bool
exists :: Maybe Bool
$sel:exists:ExpectedAttributeValue' :: ExpectedAttributeValue -> Maybe Bool
exists} -> Maybe Bool
exists) (\s :: ExpectedAttributeValue
s@ExpectedAttributeValue' {} Maybe Bool
a -> ExpectedAttributeValue
s {$sel:exists:ExpectedAttributeValue' :: Maybe Bool
exists = Maybe Bool
a} :: ExpectedAttributeValue)

-- | Represents the data for the expected attribute.
--
-- Each attribute value is described as a name-value pair. The name is the
-- data type, and the value is the data itself.
--
-- For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes Data Types>
-- in the /Amazon DynamoDB Developer Guide/.
expectedAttributeValue_value :: Lens.Lens' ExpectedAttributeValue (Prelude.Maybe AttributeValue)
expectedAttributeValue_value :: (Maybe AttributeValue -> f (Maybe AttributeValue))
-> ExpectedAttributeValue -> f ExpectedAttributeValue
expectedAttributeValue_value = (ExpectedAttributeValue -> Maybe AttributeValue)
-> (ExpectedAttributeValue
    -> Maybe AttributeValue -> ExpectedAttributeValue)
-> Lens
     ExpectedAttributeValue
     ExpectedAttributeValue
     (Maybe AttributeValue)
     (Maybe AttributeValue)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExpectedAttributeValue' {Maybe AttributeValue
value :: Maybe AttributeValue
$sel:value:ExpectedAttributeValue' :: ExpectedAttributeValue -> Maybe AttributeValue
value} -> Maybe AttributeValue
value) (\s :: ExpectedAttributeValue
s@ExpectedAttributeValue' {} Maybe AttributeValue
a -> ExpectedAttributeValue
s {$sel:value:ExpectedAttributeValue' :: Maybe AttributeValue
value = Maybe AttributeValue
a} :: ExpectedAttributeValue)

-- | A comparator for evaluating attributes in the @AttributeValueList@. For
-- example, equals, greater than, less than, etc.
--
-- The following comparison operators are available:
--
-- @EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN@
--
-- The following are descriptions of each comparison operator.
--
-- -   @EQ@ : Equal. @EQ@ is supported for all data types, including lists
--     and maps.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, Binary, String Set, Number Set, or Binary
--     Set. If an item contains an @AttributeValue@ element of a different
--     type than the one provided in the request, the value does not match.
--     For example, @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @NE@ : Not equal. @NE@ is supported for all data types, including
--     lists and maps.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String, Number, Binary, String Set, Number Set, or Binary Set. If an
--     item contains an @AttributeValue@ of a different type than the one
--     provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @LE@ : Less than or equal.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @LT@ : Less than.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String, Number, or Binary (not a set type). If an item contains an
--     @AttributeValue@ element of a different type than the one provided
--     in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @GE@ : Greater than or equal.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @GT@ : Greater than.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @NOT_NULL@ : The attribute exists. @NOT_NULL@ is supported for all
--     data types, including lists and maps.
--
--     This operator tests for the existence of an attribute, not its data
--     type. If the data type of attribute \"@a@\" is null, and you
--     evaluate it using @NOT_NULL@, the result is a Boolean @true@. This
--     result is because the attribute \"@a@\" exists; its data type is not
--     relevant to the @NOT_NULL@ comparison operator.
--
-- -   @NULL@ : The attribute does not exist. @NULL@ is supported for all
--     data types, including lists and maps.
--
--     This operator tests for the nonexistence of an attribute, not its
--     data type. If the data type of attribute \"@a@\" is null, and you
--     evaluate it using @NULL@, the result is a Boolean @false@. This is
--     because the attribute \"@a@\" exists; its data type is not relevant
--     to the @NULL@ comparison operator.
--
-- -   @CONTAINS@ : Checks for a subsequence, or value in a set.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If the target
--     attribute of the comparison is of type String, then the operator
--     checks for a substring match. If the target attribute of the
--     comparison is of type Binary, then the operator looks for a
--     subsequence of the target that matches the input. If the target
--     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
--     \"@BS@\"), then the operator evaluates to true if it finds an exact
--     match with any member of the set.
--
--     CONTAINS is supported for lists: When evaluating \"@a CONTAINS b@\",
--     \"@a@\" can be a list; however, \"@b@\" cannot be a set, a map, or a
--     list.
--
-- -   @NOT_CONTAINS@ : Checks for absence of a subsequence, or absence of
--     a value in a set.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If the target
--     attribute of the comparison is a String, then the operator checks
--     for the absence of a substring match. If the target attribute of the
--     comparison is Binary, then the operator checks for the absence of a
--     subsequence of the target that matches the input. If the target
--     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
--     \"@BS@\"), then the operator evaluates to true if it /does not/ find
--     an exact match with any member of the set.
--
--     NOT_CONTAINS is supported for lists: When evaluating
--     \"@a NOT CONTAINS b@\", \"@a@\" can be a list; however, \"@b@\"
--     cannot be a set, a map, or a list.
--
-- -   @BEGINS_WITH@ : Checks for a prefix.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String or Binary (not a Number or a set type). The target attribute
--     of the comparison must be of type String or Binary (not a Number or
--     a set type).
--
-- -   @IN@ : Checks for matching elements in a list.
--
--     @AttributeValueList@ can contain one or more @AttributeValue@
--     elements of type String, Number, or Binary. These attributes are
--     compared against an existing attribute of an item. If any elements
--     of the input are equal to the item attribute, the expression
--     evaluates to true.
--
-- -   @BETWEEN@ : Greater than or equal to the first value, and less than
--     or equal to the second value.
--
--     @AttributeValueList@ must contain two @AttributeValue@ elements of
--     the same type, either String, Number, or Binary (not a set type). A
--     target attribute matches if the target value is greater than, or
--     equal to, the first element and less than, or equal to, the second
--     element. If an item contains an @AttributeValue@ element of a
--     different type than the one provided in the request, the value does
--     not match. For example, @{\"S\":\"6\"}@ does not compare to
--     @{\"N\":\"6\"}@. Also, @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@
expectedAttributeValue_comparisonOperator :: Lens.Lens' ExpectedAttributeValue (Prelude.Maybe ComparisonOperator)
expectedAttributeValue_comparisonOperator :: (Maybe ComparisonOperator -> f (Maybe ComparisonOperator))
-> ExpectedAttributeValue -> f ExpectedAttributeValue
expectedAttributeValue_comparisonOperator = (ExpectedAttributeValue -> Maybe ComparisonOperator)
-> (ExpectedAttributeValue
    -> Maybe ComparisonOperator -> ExpectedAttributeValue)
-> Lens
     ExpectedAttributeValue
     ExpectedAttributeValue
     (Maybe ComparisonOperator)
     (Maybe ComparisonOperator)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExpectedAttributeValue' {Maybe ComparisonOperator
comparisonOperator :: Maybe ComparisonOperator
$sel:comparisonOperator:ExpectedAttributeValue' :: ExpectedAttributeValue -> Maybe ComparisonOperator
comparisonOperator} -> Maybe ComparisonOperator
comparisonOperator) (\s :: ExpectedAttributeValue
s@ExpectedAttributeValue' {} Maybe ComparisonOperator
a -> ExpectedAttributeValue
s {$sel:comparisonOperator:ExpectedAttributeValue' :: Maybe ComparisonOperator
comparisonOperator = Maybe ComparisonOperator
a} :: ExpectedAttributeValue)

instance Prelude.Hashable ExpectedAttributeValue

instance Prelude.NFData ExpectedAttributeValue

instance Core.ToJSON ExpectedAttributeValue where
  toJSON :: ExpectedAttributeValue -> Value
toJSON ExpectedAttributeValue' {Maybe Bool
Maybe [AttributeValue]
Maybe AttributeValue
Maybe ComparisonOperator
comparisonOperator :: Maybe ComparisonOperator
value :: Maybe AttributeValue
exists :: Maybe Bool
attributeValueList :: Maybe [AttributeValue]
$sel:comparisonOperator:ExpectedAttributeValue' :: ExpectedAttributeValue -> Maybe ComparisonOperator
$sel:value:ExpectedAttributeValue' :: ExpectedAttributeValue -> Maybe AttributeValue
$sel:exists:ExpectedAttributeValue' :: ExpectedAttributeValue -> Maybe Bool
$sel:attributeValueList:ExpectedAttributeValue' :: ExpectedAttributeValue -> Maybe [AttributeValue]
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"AttributeValueList" Text -> [AttributeValue] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([AttributeValue] -> Pair) -> Maybe [AttributeValue] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [AttributeValue]
attributeValueList,
            (Text
"Exists" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
exists,
            (Text
"Value" Text -> AttributeValue -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (AttributeValue -> Pair) -> Maybe AttributeValue -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe AttributeValue
value,
            (Text
"ComparisonOperator" Text -> ComparisonOperator -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ComparisonOperator -> Pair)
-> Maybe ComparisonOperator -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ComparisonOperator
comparisonOperator
          ]
      )