{-# LANGUAGE OverloadedStrings, RecordWildCards, TupleSections #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE TypeFamilies #-}


{- |
= DOMStorage

Query and modify DOM storage.
-}


module CDP.Domains.DOMStorage (module CDP.Domains.DOMStorage) where

import           Control.Applicative  ((<$>))
import           Control.Monad
import           Control.Monad.Loops
import           Control.Monad.Trans  (liftIO)
import qualified Data.Map             as M
import           Data.Maybe          
import Data.Functor.Identity
import Data.String
import qualified Data.Text as T
import qualified Data.List as List
import qualified Data.Text.IO         as TI
import qualified Data.Vector          as V
import Data.Aeson.Types (Parser(..))
import           Data.Aeson           (FromJSON (..), ToJSON (..), (.:), (.:?), (.=), (.!=), (.:!))
import qualified Data.Aeson           as A
import qualified Network.HTTP.Simple as Http
import qualified Network.URI          as Uri
import qualified Network.WebSockets as WS
import Control.Concurrent
import qualified Data.ByteString.Lazy as BS
import qualified Data.Map as Map
import Data.Proxy
import System.Random
import GHC.Generics
import Data.Char
import Data.Default

import CDP.Internal.Utils




-- | Type 'DOMStorage.SerializedStorageKey'.
type DOMStorageSerializedStorageKey = T.Text

-- | Type 'DOMStorage.StorageId'.
--   DOM Storage identifier.
data DOMStorageStorageId = DOMStorageStorageId
  {
    -- | Security origin for the storage.
    DOMStorageStorageId -> Maybe Text
dOMStorageStorageIdSecurityOrigin :: Maybe T.Text,
    -- | Represents a key by which DOM Storage keys its CachedStorageAreas
    DOMStorageStorageId -> Maybe Text
dOMStorageStorageIdStorageKey :: Maybe DOMStorageSerializedStorageKey,
    -- | Whether the storage is local storage (not session storage).
    DOMStorageStorageId -> Bool
dOMStorageStorageIdIsLocalStorage :: Bool
  }
  deriving (DOMStorageStorageId -> DOMStorageStorageId -> Bool
(DOMStorageStorageId -> DOMStorageStorageId -> Bool)
-> (DOMStorageStorageId -> DOMStorageStorageId -> Bool)
-> Eq DOMStorageStorageId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DOMStorageStorageId -> DOMStorageStorageId -> Bool
$c/= :: DOMStorageStorageId -> DOMStorageStorageId -> Bool
== :: DOMStorageStorageId -> DOMStorageStorageId -> Bool
$c== :: DOMStorageStorageId -> DOMStorageStorageId -> Bool
Eq, Int -> DOMStorageStorageId -> ShowS
[DOMStorageStorageId] -> ShowS
DOMStorageStorageId -> String
(Int -> DOMStorageStorageId -> ShowS)
-> (DOMStorageStorageId -> String)
-> ([DOMStorageStorageId] -> ShowS)
-> Show DOMStorageStorageId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DOMStorageStorageId] -> ShowS
$cshowList :: [DOMStorageStorageId] -> ShowS
show :: DOMStorageStorageId -> String
$cshow :: DOMStorageStorageId -> String
showsPrec :: Int -> DOMStorageStorageId -> ShowS
$cshowsPrec :: Int -> DOMStorageStorageId -> ShowS
Show)
instance FromJSON DOMStorageStorageId where
  parseJSON :: Value -> Parser DOMStorageStorageId
parseJSON = String
-> (Object -> Parser DOMStorageStorageId)
-> Value
-> Parser DOMStorageStorageId
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"DOMStorageStorageId" ((Object -> Parser DOMStorageStorageId)
 -> Value -> Parser DOMStorageStorageId)
-> (Object -> Parser DOMStorageStorageId)
-> Value
-> Parser DOMStorageStorageId
forall a b. (a -> b) -> a -> b
$ \Object
o -> Maybe Text -> Maybe Text -> Bool -> DOMStorageStorageId
DOMStorageStorageId
    (Maybe Text -> Maybe Text -> Bool -> DOMStorageStorageId)
-> Parser (Maybe Text)
-> Parser (Maybe Text -> Bool -> DOMStorageStorageId)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"securityOrigin"
    Parser (Maybe Text -> Bool -> DOMStorageStorageId)
-> Parser (Maybe Text) -> Parser (Bool -> DOMStorageStorageId)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
A..:? Text
"storageKey"
    Parser (Bool -> DOMStorageStorageId)
-> Parser Bool -> Parser DOMStorageStorageId
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Bool
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"isLocalStorage"
instance ToJSON DOMStorageStorageId where
  toJSON :: DOMStorageStorageId -> Value
toJSON DOMStorageStorageId
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"securityOrigin" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DOMStorageStorageId -> Maybe Text
dOMStorageStorageIdSecurityOrigin DOMStorageStorageId
p),
    (Text
"storageKey" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DOMStorageStorageId -> Maybe Text
dOMStorageStorageIdStorageKey DOMStorageStorageId
p),
    (Text
"isLocalStorage" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Maybe Bool
forall a. a -> Maybe a
Just (DOMStorageStorageId -> Bool
dOMStorageStorageIdIsLocalStorage DOMStorageStorageId
p)
    ]

-- | Type 'DOMStorage.Item'.
--   DOM Storage item.
type DOMStorageItem = [T.Text]

-- | Type of the 'DOMStorage.domStorageItemAdded' event.
data DOMStorageDomStorageItemAdded = DOMStorageDomStorageItemAdded
  {
    DOMStorageDomStorageItemAdded -> DOMStorageStorageId
dOMStorageDomStorageItemAddedStorageId :: DOMStorageStorageId,
    DOMStorageDomStorageItemAdded -> Text
dOMStorageDomStorageItemAddedKey :: T.Text,
    DOMStorageDomStorageItemAdded -> Text
dOMStorageDomStorageItemAddedNewValue :: T.Text
  }
  deriving (DOMStorageDomStorageItemAdded
-> DOMStorageDomStorageItemAdded -> Bool
(DOMStorageDomStorageItemAdded
 -> DOMStorageDomStorageItemAdded -> Bool)
-> (DOMStorageDomStorageItemAdded
    -> DOMStorageDomStorageItemAdded -> Bool)
-> Eq DOMStorageDomStorageItemAdded
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DOMStorageDomStorageItemAdded
-> DOMStorageDomStorageItemAdded -> Bool
$c/= :: DOMStorageDomStorageItemAdded
-> DOMStorageDomStorageItemAdded -> Bool
== :: DOMStorageDomStorageItemAdded
-> DOMStorageDomStorageItemAdded -> Bool
$c== :: DOMStorageDomStorageItemAdded
-> DOMStorageDomStorageItemAdded -> Bool
Eq, Int -> DOMStorageDomStorageItemAdded -> ShowS
[DOMStorageDomStorageItemAdded] -> ShowS
DOMStorageDomStorageItemAdded -> String
(Int -> DOMStorageDomStorageItemAdded -> ShowS)
-> (DOMStorageDomStorageItemAdded -> String)
-> ([DOMStorageDomStorageItemAdded] -> ShowS)
-> Show DOMStorageDomStorageItemAdded
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DOMStorageDomStorageItemAdded] -> ShowS
$cshowList :: [DOMStorageDomStorageItemAdded] -> ShowS
show :: DOMStorageDomStorageItemAdded -> String
$cshow :: DOMStorageDomStorageItemAdded -> String
showsPrec :: Int -> DOMStorageDomStorageItemAdded -> ShowS
$cshowsPrec :: Int -> DOMStorageDomStorageItemAdded -> ShowS
Show)
instance FromJSON DOMStorageDomStorageItemAdded where
  parseJSON :: Value -> Parser DOMStorageDomStorageItemAdded
parseJSON = String
-> (Object -> Parser DOMStorageDomStorageItemAdded)
-> Value
-> Parser DOMStorageDomStorageItemAdded
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"DOMStorageDomStorageItemAdded" ((Object -> Parser DOMStorageDomStorageItemAdded)
 -> Value -> Parser DOMStorageDomStorageItemAdded)
-> (Object -> Parser DOMStorageDomStorageItemAdded)
-> Value
-> Parser DOMStorageDomStorageItemAdded
forall a b. (a -> b) -> a -> b
$ \Object
o -> DOMStorageStorageId
-> Text -> Text -> DOMStorageDomStorageItemAdded
DOMStorageDomStorageItemAdded
    (DOMStorageStorageId
 -> Text -> Text -> DOMStorageDomStorageItemAdded)
-> Parser DOMStorageStorageId
-> Parser (Text -> Text -> DOMStorageDomStorageItemAdded)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser DOMStorageStorageId
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"storageId"
    Parser (Text -> Text -> DOMStorageDomStorageItemAdded)
-> Parser Text -> Parser (Text -> DOMStorageDomStorageItemAdded)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"key"
    Parser (Text -> DOMStorageDomStorageItemAdded)
-> Parser Text -> Parser DOMStorageDomStorageItemAdded
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"newValue"
instance Event DOMStorageDomStorageItemAdded where
  eventName :: Proxy DOMStorageDomStorageItemAdded -> String
eventName Proxy DOMStorageDomStorageItemAdded
_ = String
"DOMStorage.domStorageItemAdded"

-- | Type of the 'DOMStorage.domStorageItemRemoved' event.
data DOMStorageDomStorageItemRemoved = DOMStorageDomStorageItemRemoved
  {
    DOMStorageDomStorageItemRemoved -> DOMStorageStorageId
dOMStorageDomStorageItemRemovedStorageId :: DOMStorageStorageId,
    DOMStorageDomStorageItemRemoved -> Text
dOMStorageDomStorageItemRemovedKey :: T.Text
  }
  deriving (DOMStorageDomStorageItemRemoved
-> DOMStorageDomStorageItemRemoved -> Bool
(DOMStorageDomStorageItemRemoved
 -> DOMStorageDomStorageItemRemoved -> Bool)
-> (DOMStorageDomStorageItemRemoved
    -> DOMStorageDomStorageItemRemoved -> Bool)
-> Eq DOMStorageDomStorageItemRemoved
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DOMStorageDomStorageItemRemoved
-> DOMStorageDomStorageItemRemoved -> Bool
$c/= :: DOMStorageDomStorageItemRemoved
-> DOMStorageDomStorageItemRemoved -> Bool
== :: DOMStorageDomStorageItemRemoved
-> DOMStorageDomStorageItemRemoved -> Bool
$c== :: DOMStorageDomStorageItemRemoved
-> DOMStorageDomStorageItemRemoved -> Bool
Eq, Int -> DOMStorageDomStorageItemRemoved -> ShowS
[DOMStorageDomStorageItemRemoved] -> ShowS
DOMStorageDomStorageItemRemoved -> String
(Int -> DOMStorageDomStorageItemRemoved -> ShowS)
-> (DOMStorageDomStorageItemRemoved -> String)
-> ([DOMStorageDomStorageItemRemoved] -> ShowS)
-> Show DOMStorageDomStorageItemRemoved
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DOMStorageDomStorageItemRemoved] -> ShowS
$cshowList :: [DOMStorageDomStorageItemRemoved] -> ShowS
show :: DOMStorageDomStorageItemRemoved -> String
$cshow :: DOMStorageDomStorageItemRemoved -> String
showsPrec :: Int -> DOMStorageDomStorageItemRemoved -> ShowS
$cshowsPrec :: Int -> DOMStorageDomStorageItemRemoved -> ShowS
Show)
instance FromJSON DOMStorageDomStorageItemRemoved where
  parseJSON :: Value -> Parser DOMStorageDomStorageItemRemoved
parseJSON = String
-> (Object -> Parser DOMStorageDomStorageItemRemoved)
-> Value
-> Parser DOMStorageDomStorageItemRemoved
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"DOMStorageDomStorageItemRemoved" ((Object -> Parser DOMStorageDomStorageItemRemoved)
 -> Value -> Parser DOMStorageDomStorageItemRemoved)
-> (Object -> Parser DOMStorageDomStorageItemRemoved)
-> Value
-> Parser DOMStorageDomStorageItemRemoved
forall a b. (a -> b) -> a -> b
$ \Object
o -> DOMStorageStorageId -> Text -> DOMStorageDomStorageItemRemoved
DOMStorageDomStorageItemRemoved
    (DOMStorageStorageId -> Text -> DOMStorageDomStorageItemRemoved)
-> Parser DOMStorageStorageId
-> Parser (Text -> DOMStorageDomStorageItemRemoved)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser DOMStorageStorageId
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"storageId"
    Parser (Text -> DOMStorageDomStorageItemRemoved)
-> Parser Text -> Parser DOMStorageDomStorageItemRemoved
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"key"
instance Event DOMStorageDomStorageItemRemoved where
  eventName :: Proxy DOMStorageDomStorageItemRemoved -> String
eventName Proxy DOMStorageDomStorageItemRemoved
_ = String
"DOMStorage.domStorageItemRemoved"

-- | Type of the 'DOMStorage.domStorageItemUpdated' event.
data DOMStorageDomStorageItemUpdated = DOMStorageDomStorageItemUpdated
  {
    DOMStorageDomStorageItemUpdated -> DOMStorageStorageId
dOMStorageDomStorageItemUpdatedStorageId :: DOMStorageStorageId,
    DOMStorageDomStorageItemUpdated -> Text
dOMStorageDomStorageItemUpdatedKey :: T.Text,
    DOMStorageDomStorageItemUpdated -> Text
dOMStorageDomStorageItemUpdatedOldValue :: T.Text,
    DOMStorageDomStorageItemUpdated -> Text
dOMStorageDomStorageItemUpdatedNewValue :: T.Text
  }
  deriving (DOMStorageDomStorageItemUpdated
-> DOMStorageDomStorageItemUpdated -> Bool
(DOMStorageDomStorageItemUpdated
 -> DOMStorageDomStorageItemUpdated -> Bool)
-> (DOMStorageDomStorageItemUpdated
    -> DOMStorageDomStorageItemUpdated -> Bool)
-> Eq DOMStorageDomStorageItemUpdated
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DOMStorageDomStorageItemUpdated
-> DOMStorageDomStorageItemUpdated -> Bool
$c/= :: DOMStorageDomStorageItemUpdated
-> DOMStorageDomStorageItemUpdated -> Bool
== :: DOMStorageDomStorageItemUpdated
-> DOMStorageDomStorageItemUpdated -> Bool
$c== :: DOMStorageDomStorageItemUpdated
-> DOMStorageDomStorageItemUpdated -> Bool
Eq, Int -> DOMStorageDomStorageItemUpdated -> ShowS
[DOMStorageDomStorageItemUpdated] -> ShowS
DOMStorageDomStorageItemUpdated -> String
(Int -> DOMStorageDomStorageItemUpdated -> ShowS)
-> (DOMStorageDomStorageItemUpdated -> String)
-> ([DOMStorageDomStorageItemUpdated] -> ShowS)
-> Show DOMStorageDomStorageItemUpdated
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DOMStorageDomStorageItemUpdated] -> ShowS
$cshowList :: [DOMStorageDomStorageItemUpdated] -> ShowS
show :: DOMStorageDomStorageItemUpdated -> String
$cshow :: DOMStorageDomStorageItemUpdated -> String
showsPrec :: Int -> DOMStorageDomStorageItemUpdated -> ShowS
$cshowsPrec :: Int -> DOMStorageDomStorageItemUpdated -> ShowS
Show)
instance FromJSON DOMStorageDomStorageItemUpdated where
  parseJSON :: Value -> Parser DOMStorageDomStorageItemUpdated
parseJSON = String
-> (Object -> Parser DOMStorageDomStorageItemUpdated)
-> Value
-> Parser DOMStorageDomStorageItemUpdated
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"DOMStorageDomStorageItemUpdated" ((Object -> Parser DOMStorageDomStorageItemUpdated)
 -> Value -> Parser DOMStorageDomStorageItemUpdated)
-> (Object -> Parser DOMStorageDomStorageItemUpdated)
-> Value
-> Parser DOMStorageDomStorageItemUpdated
forall a b. (a -> b) -> a -> b
$ \Object
o -> DOMStorageStorageId
-> Text -> Text -> Text -> DOMStorageDomStorageItemUpdated
DOMStorageDomStorageItemUpdated
    (DOMStorageStorageId
 -> Text -> Text -> Text -> DOMStorageDomStorageItemUpdated)
-> Parser DOMStorageStorageId
-> Parser (Text -> Text -> Text -> DOMStorageDomStorageItemUpdated)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser DOMStorageStorageId
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"storageId"
    Parser (Text -> Text -> Text -> DOMStorageDomStorageItemUpdated)
-> Parser Text
-> Parser (Text -> Text -> DOMStorageDomStorageItemUpdated)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"key"
    Parser (Text -> Text -> DOMStorageDomStorageItemUpdated)
-> Parser Text -> Parser (Text -> DOMStorageDomStorageItemUpdated)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"oldValue"
    Parser (Text -> DOMStorageDomStorageItemUpdated)
-> Parser Text -> Parser DOMStorageDomStorageItemUpdated
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"newValue"
instance Event DOMStorageDomStorageItemUpdated where
  eventName :: Proxy DOMStorageDomStorageItemUpdated -> String
eventName Proxy DOMStorageDomStorageItemUpdated
_ = String
"DOMStorage.domStorageItemUpdated"

-- | Type of the 'DOMStorage.domStorageItemsCleared' event.
data DOMStorageDomStorageItemsCleared = DOMStorageDomStorageItemsCleared
  {
    DOMStorageDomStorageItemsCleared -> DOMStorageStorageId
dOMStorageDomStorageItemsClearedStorageId :: DOMStorageStorageId
  }
  deriving (DOMStorageDomStorageItemsCleared
-> DOMStorageDomStorageItemsCleared -> Bool
(DOMStorageDomStorageItemsCleared
 -> DOMStorageDomStorageItemsCleared -> Bool)
-> (DOMStorageDomStorageItemsCleared
    -> DOMStorageDomStorageItemsCleared -> Bool)
-> Eq DOMStorageDomStorageItemsCleared
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DOMStorageDomStorageItemsCleared
-> DOMStorageDomStorageItemsCleared -> Bool
$c/= :: DOMStorageDomStorageItemsCleared
-> DOMStorageDomStorageItemsCleared -> Bool
== :: DOMStorageDomStorageItemsCleared
-> DOMStorageDomStorageItemsCleared -> Bool
$c== :: DOMStorageDomStorageItemsCleared
-> DOMStorageDomStorageItemsCleared -> Bool
Eq, Int -> DOMStorageDomStorageItemsCleared -> ShowS
[DOMStorageDomStorageItemsCleared] -> ShowS
DOMStorageDomStorageItemsCleared -> String
(Int -> DOMStorageDomStorageItemsCleared -> ShowS)
-> (DOMStorageDomStorageItemsCleared -> String)
-> ([DOMStorageDomStorageItemsCleared] -> ShowS)
-> Show DOMStorageDomStorageItemsCleared
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DOMStorageDomStorageItemsCleared] -> ShowS
$cshowList :: [DOMStorageDomStorageItemsCleared] -> ShowS
show :: DOMStorageDomStorageItemsCleared -> String
$cshow :: DOMStorageDomStorageItemsCleared -> String
showsPrec :: Int -> DOMStorageDomStorageItemsCleared -> ShowS
$cshowsPrec :: Int -> DOMStorageDomStorageItemsCleared -> ShowS
Show)
instance FromJSON DOMStorageDomStorageItemsCleared where
  parseJSON :: Value -> Parser DOMStorageDomStorageItemsCleared
parseJSON = String
-> (Object -> Parser DOMStorageDomStorageItemsCleared)
-> Value
-> Parser DOMStorageDomStorageItemsCleared
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"DOMStorageDomStorageItemsCleared" ((Object -> Parser DOMStorageDomStorageItemsCleared)
 -> Value -> Parser DOMStorageDomStorageItemsCleared)
-> (Object -> Parser DOMStorageDomStorageItemsCleared)
-> Value
-> Parser DOMStorageDomStorageItemsCleared
forall a b. (a -> b) -> a -> b
$ \Object
o -> DOMStorageStorageId -> DOMStorageDomStorageItemsCleared
DOMStorageDomStorageItemsCleared
    (DOMStorageStorageId -> DOMStorageDomStorageItemsCleared)
-> Parser DOMStorageStorageId
-> Parser DOMStorageDomStorageItemsCleared
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser DOMStorageStorageId
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"storageId"
instance Event DOMStorageDomStorageItemsCleared where
  eventName :: Proxy DOMStorageDomStorageItemsCleared -> String
eventName Proxy DOMStorageDomStorageItemsCleared
_ = String
"DOMStorage.domStorageItemsCleared"


-- | Parameters of the 'DOMStorage.clear' command.
data PDOMStorageClear = PDOMStorageClear
  {
    PDOMStorageClear -> DOMStorageStorageId
pDOMStorageClearStorageId :: DOMStorageStorageId
  }
  deriving (PDOMStorageClear -> PDOMStorageClear -> Bool
(PDOMStorageClear -> PDOMStorageClear -> Bool)
-> (PDOMStorageClear -> PDOMStorageClear -> Bool)
-> Eq PDOMStorageClear
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDOMStorageClear -> PDOMStorageClear -> Bool
$c/= :: PDOMStorageClear -> PDOMStorageClear -> Bool
== :: PDOMStorageClear -> PDOMStorageClear -> Bool
$c== :: PDOMStorageClear -> PDOMStorageClear -> Bool
Eq, Int -> PDOMStorageClear -> ShowS
[PDOMStorageClear] -> ShowS
PDOMStorageClear -> String
(Int -> PDOMStorageClear -> ShowS)
-> (PDOMStorageClear -> String)
-> ([PDOMStorageClear] -> ShowS)
-> Show PDOMStorageClear
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDOMStorageClear] -> ShowS
$cshowList :: [PDOMStorageClear] -> ShowS
show :: PDOMStorageClear -> String
$cshow :: PDOMStorageClear -> String
showsPrec :: Int -> PDOMStorageClear -> ShowS
$cshowsPrec :: Int -> PDOMStorageClear -> ShowS
Show)
pDOMStorageClear
  :: DOMStorageStorageId
  -> PDOMStorageClear
pDOMStorageClear :: DOMStorageStorageId -> PDOMStorageClear
pDOMStorageClear
  DOMStorageStorageId
arg_pDOMStorageClearStorageId
  = DOMStorageStorageId -> PDOMStorageClear
PDOMStorageClear
    DOMStorageStorageId
arg_pDOMStorageClearStorageId
instance ToJSON PDOMStorageClear where
  toJSON :: PDOMStorageClear -> Value
toJSON PDOMStorageClear
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"storageId" Text -> DOMStorageStorageId -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (DOMStorageStorageId -> Pair)
-> Maybe DOMStorageStorageId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DOMStorageStorageId -> Maybe DOMStorageStorageId
forall a. a -> Maybe a
Just (PDOMStorageClear -> DOMStorageStorageId
pDOMStorageClearStorageId PDOMStorageClear
p)
    ]
instance Command PDOMStorageClear where
  type CommandResponse PDOMStorageClear = ()
  commandName :: Proxy PDOMStorageClear -> String
commandName Proxy PDOMStorageClear
_ = String
"DOMStorage.clear"
  fromJSON :: Proxy PDOMStorageClear
-> Value -> Result (CommandResponse PDOMStorageClear)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PDOMStorageClear -> Result ())
-> Proxy PDOMStorageClear
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PDOMStorageClear -> ())
-> Proxy PDOMStorageClear
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PDOMStorageClear -> ()
forall a b. a -> b -> a
const ()

-- | Disables storage tracking, prevents storage events from being sent to the client.

-- | Parameters of the 'DOMStorage.disable' command.
data PDOMStorageDisable = PDOMStorageDisable
  deriving (PDOMStorageDisable -> PDOMStorageDisable -> Bool
(PDOMStorageDisable -> PDOMStorageDisable -> Bool)
-> (PDOMStorageDisable -> PDOMStorageDisable -> Bool)
-> Eq PDOMStorageDisable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDOMStorageDisable -> PDOMStorageDisable -> Bool
$c/= :: PDOMStorageDisable -> PDOMStorageDisable -> Bool
== :: PDOMStorageDisable -> PDOMStorageDisable -> Bool
$c== :: PDOMStorageDisable -> PDOMStorageDisable -> Bool
Eq, Int -> PDOMStorageDisable -> ShowS
[PDOMStorageDisable] -> ShowS
PDOMStorageDisable -> String
(Int -> PDOMStorageDisable -> ShowS)
-> (PDOMStorageDisable -> String)
-> ([PDOMStorageDisable] -> ShowS)
-> Show PDOMStorageDisable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDOMStorageDisable] -> ShowS
$cshowList :: [PDOMStorageDisable] -> ShowS
show :: PDOMStorageDisable -> String
$cshow :: PDOMStorageDisable -> String
showsPrec :: Int -> PDOMStorageDisable -> ShowS
$cshowsPrec :: Int -> PDOMStorageDisable -> ShowS
Show)
pDOMStorageDisable
  :: PDOMStorageDisable
pDOMStorageDisable :: PDOMStorageDisable
pDOMStorageDisable
  = PDOMStorageDisable
PDOMStorageDisable
instance ToJSON PDOMStorageDisable where
  toJSON :: PDOMStorageDisable -> Value
toJSON PDOMStorageDisable
_ = Value
A.Null
instance Command PDOMStorageDisable where
  type CommandResponse PDOMStorageDisable = ()
  commandName :: Proxy PDOMStorageDisable -> String
commandName Proxy PDOMStorageDisable
_ = String
"DOMStorage.disable"
  fromJSON :: Proxy PDOMStorageDisable
-> Value -> Result (CommandResponse PDOMStorageDisable)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PDOMStorageDisable -> Result ())
-> Proxy PDOMStorageDisable
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PDOMStorageDisable -> ())
-> Proxy PDOMStorageDisable
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PDOMStorageDisable -> ()
forall a b. a -> b -> a
const ()

-- | Enables storage tracking, storage events will now be delivered to the client.

-- | Parameters of the 'DOMStorage.enable' command.
data PDOMStorageEnable = PDOMStorageEnable
  deriving (PDOMStorageEnable -> PDOMStorageEnable -> Bool
(PDOMStorageEnable -> PDOMStorageEnable -> Bool)
-> (PDOMStorageEnable -> PDOMStorageEnable -> Bool)
-> Eq PDOMStorageEnable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDOMStorageEnable -> PDOMStorageEnable -> Bool
$c/= :: PDOMStorageEnable -> PDOMStorageEnable -> Bool
== :: PDOMStorageEnable -> PDOMStorageEnable -> Bool
$c== :: PDOMStorageEnable -> PDOMStorageEnable -> Bool
Eq, Int -> PDOMStorageEnable -> ShowS
[PDOMStorageEnable] -> ShowS
PDOMStorageEnable -> String
(Int -> PDOMStorageEnable -> ShowS)
-> (PDOMStorageEnable -> String)
-> ([PDOMStorageEnable] -> ShowS)
-> Show PDOMStorageEnable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDOMStorageEnable] -> ShowS
$cshowList :: [PDOMStorageEnable] -> ShowS
show :: PDOMStorageEnable -> String
$cshow :: PDOMStorageEnable -> String
showsPrec :: Int -> PDOMStorageEnable -> ShowS
$cshowsPrec :: Int -> PDOMStorageEnable -> ShowS
Show)
pDOMStorageEnable
  :: PDOMStorageEnable
pDOMStorageEnable :: PDOMStorageEnable
pDOMStorageEnable
  = PDOMStorageEnable
PDOMStorageEnable
instance ToJSON PDOMStorageEnable where
  toJSON :: PDOMStorageEnable -> Value
toJSON PDOMStorageEnable
_ = Value
A.Null
instance Command PDOMStorageEnable where
  type CommandResponse PDOMStorageEnable = ()
  commandName :: Proxy PDOMStorageEnable -> String
commandName Proxy PDOMStorageEnable
_ = String
"DOMStorage.enable"
  fromJSON :: Proxy PDOMStorageEnable
-> Value -> Result (CommandResponse PDOMStorageEnable)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PDOMStorageEnable -> Result ())
-> Proxy PDOMStorageEnable
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PDOMStorageEnable -> ())
-> Proxy PDOMStorageEnable
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PDOMStorageEnable -> ()
forall a b. a -> b -> a
const ()


-- | Parameters of the 'DOMStorage.getDOMStorageItems' command.
data PDOMStorageGetDOMStorageItems = PDOMStorageGetDOMStorageItems
  {
    PDOMStorageGetDOMStorageItems -> DOMStorageStorageId
pDOMStorageGetDOMStorageItemsStorageId :: DOMStorageStorageId
  }
  deriving (PDOMStorageGetDOMStorageItems
-> PDOMStorageGetDOMStorageItems -> Bool
(PDOMStorageGetDOMStorageItems
 -> PDOMStorageGetDOMStorageItems -> Bool)
-> (PDOMStorageGetDOMStorageItems
    -> PDOMStorageGetDOMStorageItems -> Bool)
-> Eq PDOMStorageGetDOMStorageItems
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDOMStorageGetDOMStorageItems
-> PDOMStorageGetDOMStorageItems -> Bool
$c/= :: PDOMStorageGetDOMStorageItems
-> PDOMStorageGetDOMStorageItems -> Bool
== :: PDOMStorageGetDOMStorageItems
-> PDOMStorageGetDOMStorageItems -> Bool
$c== :: PDOMStorageGetDOMStorageItems
-> PDOMStorageGetDOMStorageItems -> Bool
Eq, Int -> PDOMStorageGetDOMStorageItems -> ShowS
[PDOMStorageGetDOMStorageItems] -> ShowS
PDOMStorageGetDOMStorageItems -> String
(Int -> PDOMStorageGetDOMStorageItems -> ShowS)
-> (PDOMStorageGetDOMStorageItems -> String)
-> ([PDOMStorageGetDOMStorageItems] -> ShowS)
-> Show PDOMStorageGetDOMStorageItems
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDOMStorageGetDOMStorageItems] -> ShowS
$cshowList :: [PDOMStorageGetDOMStorageItems] -> ShowS
show :: PDOMStorageGetDOMStorageItems -> String
$cshow :: PDOMStorageGetDOMStorageItems -> String
showsPrec :: Int -> PDOMStorageGetDOMStorageItems -> ShowS
$cshowsPrec :: Int -> PDOMStorageGetDOMStorageItems -> ShowS
Show)
pDOMStorageGetDOMStorageItems
  :: DOMStorageStorageId
  -> PDOMStorageGetDOMStorageItems
pDOMStorageGetDOMStorageItems :: DOMStorageStorageId -> PDOMStorageGetDOMStorageItems
pDOMStorageGetDOMStorageItems
  DOMStorageStorageId
arg_pDOMStorageGetDOMStorageItemsStorageId
  = DOMStorageStorageId -> PDOMStorageGetDOMStorageItems
PDOMStorageGetDOMStorageItems
    DOMStorageStorageId
arg_pDOMStorageGetDOMStorageItemsStorageId
instance ToJSON PDOMStorageGetDOMStorageItems where
  toJSON :: PDOMStorageGetDOMStorageItems -> Value
toJSON PDOMStorageGetDOMStorageItems
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"storageId" Text -> DOMStorageStorageId -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (DOMStorageStorageId -> Pair)
-> Maybe DOMStorageStorageId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DOMStorageStorageId -> Maybe DOMStorageStorageId
forall a. a -> Maybe a
Just (PDOMStorageGetDOMStorageItems -> DOMStorageStorageId
pDOMStorageGetDOMStorageItemsStorageId PDOMStorageGetDOMStorageItems
p)
    ]
data DOMStorageGetDOMStorageItems = DOMStorageGetDOMStorageItems
  {
    DOMStorageGetDOMStorageItems -> [DOMStorageItem]
dOMStorageGetDOMStorageItemsEntries :: [DOMStorageItem]
  }
  deriving (DOMStorageGetDOMStorageItems
-> DOMStorageGetDOMStorageItems -> Bool
(DOMStorageGetDOMStorageItems
 -> DOMStorageGetDOMStorageItems -> Bool)
-> (DOMStorageGetDOMStorageItems
    -> DOMStorageGetDOMStorageItems -> Bool)
-> Eq DOMStorageGetDOMStorageItems
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DOMStorageGetDOMStorageItems
-> DOMStorageGetDOMStorageItems -> Bool
$c/= :: DOMStorageGetDOMStorageItems
-> DOMStorageGetDOMStorageItems -> Bool
== :: DOMStorageGetDOMStorageItems
-> DOMStorageGetDOMStorageItems -> Bool
$c== :: DOMStorageGetDOMStorageItems
-> DOMStorageGetDOMStorageItems -> Bool
Eq, Int -> DOMStorageGetDOMStorageItems -> ShowS
[DOMStorageGetDOMStorageItems] -> ShowS
DOMStorageGetDOMStorageItems -> String
(Int -> DOMStorageGetDOMStorageItems -> ShowS)
-> (DOMStorageGetDOMStorageItems -> String)
-> ([DOMStorageGetDOMStorageItems] -> ShowS)
-> Show DOMStorageGetDOMStorageItems
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DOMStorageGetDOMStorageItems] -> ShowS
$cshowList :: [DOMStorageGetDOMStorageItems] -> ShowS
show :: DOMStorageGetDOMStorageItems -> String
$cshow :: DOMStorageGetDOMStorageItems -> String
showsPrec :: Int -> DOMStorageGetDOMStorageItems -> ShowS
$cshowsPrec :: Int -> DOMStorageGetDOMStorageItems -> ShowS
Show)
instance FromJSON DOMStorageGetDOMStorageItems where
  parseJSON :: Value -> Parser DOMStorageGetDOMStorageItems
parseJSON = String
-> (Object -> Parser DOMStorageGetDOMStorageItems)
-> Value
-> Parser DOMStorageGetDOMStorageItems
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"DOMStorageGetDOMStorageItems" ((Object -> Parser DOMStorageGetDOMStorageItems)
 -> Value -> Parser DOMStorageGetDOMStorageItems)
-> (Object -> Parser DOMStorageGetDOMStorageItems)
-> Value
-> Parser DOMStorageGetDOMStorageItems
forall a b. (a -> b) -> a -> b
$ \Object
o -> [DOMStorageItem] -> DOMStorageGetDOMStorageItems
DOMStorageGetDOMStorageItems
    ([DOMStorageItem] -> DOMStorageGetDOMStorageItems)
-> Parser [DOMStorageItem] -> Parser DOMStorageGetDOMStorageItems
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser [DOMStorageItem]
forall a. FromJSON a => Object -> Text -> Parser a
A..: Text
"entries"
instance Command PDOMStorageGetDOMStorageItems where
  type CommandResponse PDOMStorageGetDOMStorageItems = DOMStorageGetDOMStorageItems
  commandName :: Proxy PDOMStorageGetDOMStorageItems -> String
commandName Proxy PDOMStorageGetDOMStorageItems
_ = String
"DOMStorage.getDOMStorageItems"


-- | Parameters of the 'DOMStorage.removeDOMStorageItem' command.
data PDOMStorageRemoveDOMStorageItem = PDOMStorageRemoveDOMStorageItem
  {
    PDOMStorageRemoveDOMStorageItem -> DOMStorageStorageId
pDOMStorageRemoveDOMStorageItemStorageId :: DOMStorageStorageId,
    PDOMStorageRemoveDOMStorageItem -> Text
pDOMStorageRemoveDOMStorageItemKey :: T.Text
  }
  deriving (PDOMStorageRemoveDOMStorageItem
-> PDOMStorageRemoveDOMStorageItem -> Bool
(PDOMStorageRemoveDOMStorageItem
 -> PDOMStorageRemoveDOMStorageItem -> Bool)
-> (PDOMStorageRemoveDOMStorageItem
    -> PDOMStorageRemoveDOMStorageItem -> Bool)
-> Eq PDOMStorageRemoveDOMStorageItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDOMStorageRemoveDOMStorageItem
-> PDOMStorageRemoveDOMStorageItem -> Bool
$c/= :: PDOMStorageRemoveDOMStorageItem
-> PDOMStorageRemoveDOMStorageItem -> Bool
== :: PDOMStorageRemoveDOMStorageItem
-> PDOMStorageRemoveDOMStorageItem -> Bool
$c== :: PDOMStorageRemoveDOMStorageItem
-> PDOMStorageRemoveDOMStorageItem -> Bool
Eq, Int -> PDOMStorageRemoveDOMStorageItem -> ShowS
[PDOMStorageRemoveDOMStorageItem] -> ShowS
PDOMStorageRemoveDOMStorageItem -> String
(Int -> PDOMStorageRemoveDOMStorageItem -> ShowS)
-> (PDOMStorageRemoveDOMStorageItem -> String)
-> ([PDOMStorageRemoveDOMStorageItem] -> ShowS)
-> Show PDOMStorageRemoveDOMStorageItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDOMStorageRemoveDOMStorageItem] -> ShowS
$cshowList :: [PDOMStorageRemoveDOMStorageItem] -> ShowS
show :: PDOMStorageRemoveDOMStorageItem -> String
$cshow :: PDOMStorageRemoveDOMStorageItem -> String
showsPrec :: Int -> PDOMStorageRemoveDOMStorageItem -> ShowS
$cshowsPrec :: Int -> PDOMStorageRemoveDOMStorageItem -> ShowS
Show)
pDOMStorageRemoveDOMStorageItem
  :: DOMStorageStorageId
  -> T.Text
  -> PDOMStorageRemoveDOMStorageItem
pDOMStorageRemoveDOMStorageItem :: DOMStorageStorageId -> Text -> PDOMStorageRemoveDOMStorageItem
pDOMStorageRemoveDOMStorageItem
  DOMStorageStorageId
arg_pDOMStorageRemoveDOMStorageItemStorageId
  Text
arg_pDOMStorageRemoveDOMStorageItemKey
  = DOMStorageStorageId -> Text -> PDOMStorageRemoveDOMStorageItem
PDOMStorageRemoveDOMStorageItem
    DOMStorageStorageId
arg_pDOMStorageRemoveDOMStorageItemStorageId
    Text
arg_pDOMStorageRemoveDOMStorageItemKey
instance ToJSON PDOMStorageRemoveDOMStorageItem where
  toJSON :: PDOMStorageRemoveDOMStorageItem -> Value
toJSON PDOMStorageRemoveDOMStorageItem
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"storageId" Text -> DOMStorageStorageId -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (DOMStorageStorageId -> Pair)
-> Maybe DOMStorageStorageId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DOMStorageStorageId -> Maybe DOMStorageStorageId
forall a. a -> Maybe a
Just (PDOMStorageRemoveDOMStorageItem -> DOMStorageStorageId
pDOMStorageRemoveDOMStorageItemStorageId PDOMStorageRemoveDOMStorageItem
p),
    (Text
"key" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Text
forall a. a -> Maybe a
Just (PDOMStorageRemoveDOMStorageItem -> Text
pDOMStorageRemoveDOMStorageItemKey PDOMStorageRemoveDOMStorageItem
p)
    ]
instance Command PDOMStorageRemoveDOMStorageItem where
  type CommandResponse PDOMStorageRemoveDOMStorageItem = ()
  commandName :: Proxy PDOMStorageRemoveDOMStorageItem -> String
commandName Proxy PDOMStorageRemoveDOMStorageItem
_ = String
"DOMStorage.removeDOMStorageItem"
  fromJSON :: Proxy PDOMStorageRemoveDOMStorageItem
-> Value
-> Result (CommandResponse PDOMStorageRemoveDOMStorageItem)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PDOMStorageRemoveDOMStorageItem -> Result ())
-> Proxy PDOMStorageRemoveDOMStorageItem
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PDOMStorageRemoveDOMStorageItem -> ())
-> Proxy PDOMStorageRemoveDOMStorageItem
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PDOMStorageRemoveDOMStorageItem -> ()
forall a b. a -> b -> a
const ()


-- | Parameters of the 'DOMStorage.setDOMStorageItem' command.
data PDOMStorageSetDOMStorageItem = PDOMStorageSetDOMStorageItem
  {
    PDOMStorageSetDOMStorageItem -> DOMStorageStorageId
pDOMStorageSetDOMStorageItemStorageId :: DOMStorageStorageId,
    PDOMStorageSetDOMStorageItem -> Text
pDOMStorageSetDOMStorageItemKey :: T.Text,
    PDOMStorageSetDOMStorageItem -> Text
pDOMStorageSetDOMStorageItemValue :: T.Text
  }
  deriving (PDOMStorageSetDOMStorageItem
-> PDOMStorageSetDOMStorageItem -> Bool
(PDOMStorageSetDOMStorageItem
 -> PDOMStorageSetDOMStorageItem -> Bool)
-> (PDOMStorageSetDOMStorageItem
    -> PDOMStorageSetDOMStorageItem -> Bool)
-> Eq PDOMStorageSetDOMStorageItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDOMStorageSetDOMStorageItem
-> PDOMStorageSetDOMStorageItem -> Bool
$c/= :: PDOMStorageSetDOMStorageItem
-> PDOMStorageSetDOMStorageItem -> Bool
== :: PDOMStorageSetDOMStorageItem
-> PDOMStorageSetDOMStorageItem -> Bool
$c== :: PDOMStorageSetDOMStorageItem
-> PDOMStorageSetDOMStorageItem -> Bool
Eq, Int -> PDOMStorageSetDOMStorageItem -> ShowS
[PDOMStorageSetDOMStorageItem] -> ShowS
PDOMStorageSetDOMStorageItem -> String
(Int -> PDOMStorageSetDOMStorageItem -> ShowS)
-> (PDOMStorageSetDOMStorageItem -> String)
-> ([PDOMStorageSetDOMStorageItem] -> ShowS)
-> Show PDOMStorageSetDOMStorageItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDOMStorageSetDOMStorageItem] -> ShowS
$cshowList :: [PDOMStorageSetDOMStorageItem] -> ShowS
show :: PDOMStorageSetDOMStorageItem -> String
$cshow :: PDOMStorageSetDOMStorageItem -> String
showsPrec :: Int -> PDOMStorageSetDOMStorageItem -> ShowS
$cshowsPrec :: Int -> PDOMStorageSetDOMStorageItem -> ShowS
Show)
pDOMStorageSetDOMStorageItem
  :: DOMStorageStorageId
  -> T.Text
  -> T.Text
  -> PDOMStorageSetDOMStorageItem
pDOMStorageSetDOMStorageItem :: DOMStorageStorageId -> Text -> Text -> PDOMStorageSetDOMStorageItem
pDOMStorageSetDOMStorageItem
  DOMStorageStorageId
arg_pDOMStorageSetDOMStorageItemStorageId
  Text
arg_pDOMStorageSetDOMStorageItemKey
  Text
arg_pDOMStorageSetDOMStorageItemValue
  = DOMStorageStorageId -> Text -> Text -> PDOMStorageSetDOMStorageItem
PDOMStorageSetDOMStorageItem
    DOMStorageStorageId
arg_pDOMStorageSetDOMStorageItemStorageId
    Text
arg_pDOMStorageSetDOMStorageItemKey
    Text
arg_pDOMStorageSetDOMStorageItemValue
instance ToJSON PDOMStorageSetDOMStorageItem where
  toJSON :: PDOMStorageSetDOMStorageItem -> Value
toJSON PDOMStorageSetDOMStorageItem
p = [Pair] -> Value
A.object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
catMaybes [
    (Text
"storageId" Text -> DOMStorageStorageId -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (DOMStorageStorageId -> Pair)
-> Maybe DOMStorageStorageId -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DOMStorageStorageId -> Maybe DOMStorageStorageId
forall a. a -> Maybe a
Just (PDOMStorageSetDOMStorageItem -> DOMStorageStorageId
pDOMStorageSetDOMStorageItemStorageId PDOMStorageSetDOMStorageItem
p),
    (Text
"key" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Text
forall a. a -> Maybe a
Just (PDOMStorageSetDOMStorageItem -> Text
pDOMStorageSetDOMStorageItemKey PDOMStorageSetDOMStorageItem
p),
    (Text
"value" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
A..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Maybe Text
forall a. a -> Maybe a
Just (PDOMStorageSetDOMStorageItem -> Text
pDOMStorageSetDOMStorageItemValue PDOMStorageSetDOMStorageItem
p)
    ]
instance Command PDOMStorageSetDOMStorageItem where
  type CommandResponse PDOMStorageSetDOMStorageItem = ()
  commandName :: Proxy PDOMStorageSetDOMStorageItem -> String
commandName Proxy PDOMStorageSetDOMStorageItem
_ = String
"DOMStorage.setDOMStorageItem"
  fromJSON :: Proxy PDOMStorageSetDOMStorageItem
-> Value -> Result (CommandResponse PDOMStorageSetDOMStorageItem)
fromJSON = Result () -> Value -> Result ()
forall a b. a -> b -> a
const (Result () -> Value -> Result ())
-> (Proxy PDOMStorageSetDOMStorageItem -> Result ())
-> Proxy PDOMStorageSetDOMStorageItem
-> Value
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Result ()
forall a. a -> Result a
A.Success (() -> Result ())
-> (Proxy PDOMStorageSetDOMStorageItem -> ())
-> Proxy PDOMStorageSetDOMStorageItem
-> Result ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> Proxy PDOMStorageSetDOMStorageItem -> ()
forall a b. a -> b -> a
const ()