{-# 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.QuickSight.Types.Parameters
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.QuickSight.Types.Parameters where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import Amazonka.QuickSight.Types.DateTimeParameter
import Amazonka.QuickSight.Types.DecimalParameter
import Amazonka.QuickSight.Types.IntegerParameter
import Amazonka.QuickSight.Types.StringParameter

-- | A list of Amazon QuickSight parameters and the list\'s override values.
--
-- /See:/ 'newParameters' smart constructor.
data Parameters = Parameters'
  { -- | The parameters that have a data type of date-time.
    Parameters -> Maybe [DateTimeParameter]
dateTimeParameters :: Prelude.Maybe [DateTimeParameter],
    -- | The parameters that have a data type of decimal.
    Parameters -> Maybe [DecimalParameter]
decimalParameters :: Prelude.Maybe [DecimalParameter],
    -- | The parameters that have a data type of integer.
    Parameters -> Maybe [IntegerParameter]
integerParameters :: Prelude.Maybe [IntegerParameter],
    -- | The parameters that have a data type of string.
    Parameters -> Maybe [StringParameter]
stringParameters :: Prelude.Maybe [StringParameter]
  }
  deriving (Parameters -> Parameters -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Parameters -> Parameters -> Bool
$c/= :: Parameters -> Parameters -> Bool
== :: Parameters -> Parameters -> Bool
$c== :: Parameters -> Parameters -> Bool
Prelude.Eq, Int -> Parameters -> ShowS
[Parameters] -> ShowS
Parameters -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Parameters] -> ShowS
$cshowList :: [Parameters] -> ShowS
show :: Parameters -> String
$cshow :: Parameters -> String
showsPrec :: Int -> Parameters -> ShowS
$cshowsPrec :: Int -> Parameters -> ShowS
Prelude.Show, forall x. Rep Parameters x -> Parameters
forall x. Parameters -> Rep Parameters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Parameters x -> Parameters
$cfrom :: forall x. Parameters -> Rep Parameters x
Prelude.Generic)

-- |
-- Create a value of 'Parameters' 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:
--
-- 'dateTimeParameters', 'parameters_dateTimeParameters' - The parameters that have a data type of date-time.
--
-- 'decimalParameters', 'parameters_decimalParameters' - The parameters that have a data type of decimal.
--
-- 'integerParameters', 'parameters_integerParameters' - The parameters that have a data type of integer.
--
-- 'stringParameters', 'parameters_stringParameters' - The parameters that have a data type of string.
newParameters ::
  Parameters
newParameters :: Parameters
newParameters =
  Parameters'
    { $sel:dateTimeParameters:Parameters' :: Maybe [DateTimeParameter]
dateTimeParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:decimalParameters:Parameters' :: Maybe [DecimalParameter]
decimalParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:integerParameters:Parameters' :: Maybe [IntegerParameter]
integerParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:stringParameters:Parameters' :: Maybe [StringParameter]
stringParameters = forall a. Maybe a
Prelude.Nothing
    }

-- | The parameters that have a data type of date-time.
parameters_dateTimeParameters :: Lens.Lens' Parameters (Prelude.Maybe [DateTimeParameter])
parameters_dateTimeParameters :: Lens' Parameters (Maybe [DateTimeParameter])
parameters_dateTimeParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Parameters' {Maybe [DateTimeParameter]
dateTimeParameters :: Maybe [DateTimeParameter]
$sel:dateTimeParameters:Parameters' :: Parameters -> Maybe [DateTimeParameter]
dateTimeParameters} -> Maybe [DateTimeParameter]
dateTimeParameters) (\s :: Parameters
s@Parameters' {} Maybe [DateTimeParameter]
a -> Parameters
s {$sel:dateTimeParameters:Parameters' :: Maybe [DateTimeParameter]
dateTimeParameters = Maybe [DateTimeParameter]
a} :: Parameters) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The parameters that have a data type of decimal.
parameters_decimalParameters :: Lens.Lens' Parameters (Prelude.Maybe [DecimalParameter])
parameters_decimalParameters :: Lens' Parameters (Maybe [DecimalParameter])
parameters_decimalParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Parameters' {Maybe [DecimalParameter]
decimalParameters :: Maybe [DecimalParameter]
$sel:decimalParameters:Parameters' :: Parameters -> Maybe [DecimalParameter]
decimalParameters} -> Maybe [DecimalParameter]
decimalParameters) (\s :: Parameters
s@Parameters' {} Maybe [DecimalParameter]
a -> Parameters
s {$sel:decimalParameters:Parameters' :: Maybe [DecimalParameter]
decimalParameters = Maybe [DecimalParameter]
a} :: Parameters) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The parameters that have a data type of integer.
parameters_integerParameters :: Lens.Lens' Parameters (Prelude.Maybe [IntegerParameter])
parameters_integerParameters :: Lens' Parameters (Maybe [IntegerParameter])
parameters_integerParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Parameters' {Maybe [IntegerParameter]
integerParameters :: Maybe [IntegerParameter]
$sel:integerParameters:Parameters' :: Parameters -> Maybe [IntegerParameter]
integerParameters} -> Maybe [IntegerParameter]
integerParameters) (\s :: Parameters
s@Parameters' {} Maybe [IntegerParameter]
a -> Parameters
s {$sel:integerParameters:Parameters' :: Maybe [IntegerParameter]
integerParameters = Maybe [IntegerParameter]
a} :: Parameters) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The parameters that have a data type of string.
parameters_stringParameters :: Lens.Lens' Parameters (Prelude.Maybe [StringParameter])
parameters_stringParameters :: Lens' Parameters (Maybe [StringParameter])
parameters_stringParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Parameters' {Maybe [StringParameter]
stringParameters :: Maybe [StringParameter]
$sel:stringParameters:Parameters' :: Parameters -> Maybe [StringParameter]
stringParameters} -> Maybe [StringParameter]
stringParameters) (\s :: Parameters
s@Parameters' {} Maybe [StringParameter]
a -> Parameters
s {$sel:stringParameters:Parameters' :: Maybe [StringParameter]
stringParameters = Maybe [StringParameter]
a} :: Parameters) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Prelude.Hashable Parameters where
  hashWithSalt :: Int -> Parameters -> Int
hashWithSalt Int
_salt Parameters' {Maybe [DateTimeParameter]
Maybe [DecimalParameter]
Maybe [IntegerParameter]
Maybe [StringParameter]
stringParameters :: Maybe [StringParameter]
integerParameters :: Maybe [IntegerParameter]
decimalParameters :: Maybe [DecimalParameter]
dateTimeParameters :: Maybe [DateTimeParameter]
$sel:stringParameters:Parameters' :: Parameters -> Maybe [StringParameter]
$sel:integerParameters:Parameters' :: Parameters -> Maybe [IntegerParameter]
$sel:decimalParameters:Parameters' :: Parameters -> Maybe [DecimalParameter]
$sel:dateTimeParameters:Parameters' :: Parameters -> Maybe [DateTimeParameter]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [DateTimeParameter]
dateTimeParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [DecimalParameter]
decimalParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [IntegerParameter]
integerParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [StringParameter]
stringParameters

instance Prelude.NFData Parameters where
  rnf :: Parameters -> ()
rnf Parameters' {Maybe [DateTimeParameter]
Maybe [DecimalParameter]
Maybe [IntegerParameter]
Maybe [StringParameter]
stringParameters :: Maybe [StringParameter]
integerParameters :: Maybe [IntegerParameter]
decimalParameters :: Maybe [DecimalParameter]
dateTimeParameters :: Maybe [DateTimeParameter]
$sel:stringParameters:Parameters' :: Parameters -> Maybe [StringParameter]
$sel:integerParameters:Parameters' :: Parameters -> Maybe [IntegerParameter]
$sel:decimalParameters:Parameters' :: Parameters -> Maybe [DecimalParameter]
$sel:dateTimeParameters:Parameters' :: Parameters -> Maybe [DateTimeParameter]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [DateTimeParameter]
dateTimeParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [DecimalParameter]
decimalParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [IntegerParameter]
integerParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [StringParameter]
stringParameters

instance Data.ToJSON Parameters where
  toJSON :: Parameters -> Value
toJSON Parameters' {Maybe [DateTimeParameter]
Maybe [DecimalParameter]
Maybe [IntegerParameter]
Maybe [StringParameter]
stringParameters :: Maybe [StringParameter]
integerParameters :: Maybe [IntegerParameter]
decimalParameters :: Maybe [DecimalParameter]
dateTimeParameters :: Maybe [DateTimeParameter]
$sel:stringParameters:Parameters' :: Parameters -> Maybe [StringParameter]
$sel:integerParameters:Parameters' :: Parameters -> Maybe [IntegerParameter]
$sel:decimalParameters:Parameters' :: Parameters -> Maybe [DecimalParameter]
$sel:dateTimeParameters:Parameters' :: Parameters -> Maybe [DateTimeParameter]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"DateTimeParameters" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [DateTimeParameter]
dateTimeParameters,
            (Key
"DecimalParameters" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [DecimalParameter]
decimalParameters,
            (Key
"IntegerParameters" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [IntegerParameter]
integerParameters,
            (Key
"StringParameters" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [StringParameter]
stringParameters
          ]
      )