{-# LANGUAGE RankNTypes #-}
module Network.Matrix.Client.Lens
  ( -- MessageText
    _mtBody
  , _mtType
  , _mtFormat
  , _mtFormattedBody
    -- RoomMessage
  , _RoomMessageText
    -- Event
  , _EventRoomMessage
  , _EventRoomReply
  , _EventRoomEdit
  , _EventUnknown
    -- EventFilter
  , efLimit
  , _efNotSenders
  , _efNotTypes
  , _efSenders
  , _efTypes
    -- PaginatedRoomMessages
  , _chunk
  , _end
  , _start
  , _state
    -- ResolvedRoomAlias
  , _roomAlias
  , _roomID
  , _servers
    -- RoomEventFilter
  , _refLimit
  , _refNotSenders
  , _refNotTypes
  , _refSenders
  , _refTypes
  , _refLazyLoadMembers
  , _refIncludeRedundantMembers
  , _refNotRooms
  , _refRooms
  , _refContainsUrl
    -- StateContent
  , _StateContentMRCreate
  , _StateContentMRCanonicalAlias
  , _StateContentMRGuestAccess
  , _StateContentMRHistoryVisibility
  , _StateContentMRName
  , _StateContentMRTopic
  , _StateContentMROther
    -- StateEvent
  , _seContent
  , _seEventId
  , _seOriginServerTimestamp
  , _sePreviousContent
  , _seRoomId
  , _seSender
  , _seStateKey
  , _seEventType
  , _seUnsigned
    -- StateFilter
  , _sfLimit
  , _sfNotSenders
  , _sfTypes
  , _sfLazyLoadMembers
  , _sfIncludeRedundantMembers
  , _sfNotRooms
  , _sfRooms
  , _sfContainsUrl
    -- RoomFilter
  , _rfNotRooms
  , _rfRooms
  , _rfEphemeral
  , _rfIncludeLeave
  , _rfState
  , _rfTimeline
  , _rfAccountData
    -- Filter
  , _filterEventFields
  , _filterEventFormat
  , _filterPresence
  , _filterAccountData
  , _filterRoom
    -- RoomEvent
  , _reContent
  , _reType
  , _reEventId
  , _reSender
    -- RoomSummary
  , _rsJoinedMemberCount
  , _rsInvitedMemberCount
    -- TimelineSync
  , _tsEvents
  , _tsLimited
  , _tsPrevBatch
    --  JoinedRoomSync
  , _jrsSummary
  , _jrsTimeline
    -- SyncResult
  , _srNextBatch
  , _srRooms
    -- SyncResultRoom
  , _srrJoin
  , _srrInvite
  ) where

import Network.Matrix.Client

import qualified Data.Aeson as J
import Data.Coerce
import qualified Data.Text as T
import qualified Data.Map.Strict as M
import Data.Profunctor (Choice, dimap, right')

type Lens' s a = forall f. Functor f => (a -> f a) -> s -> f s 
type Prism' s a = forall p f. (Choice p, Applicative f) => p a (f a) -> p s (f s) 

lens :: (s -> a) -> (s -> a -> s) -> Lens' s a
lens :: (s -> a) -> (s -> a -> s) -> Lens' s a
lens s -> a
sa s -> a -> s
sbt a -> f a
afb s
s = s -> a -> s
sbt s
s (a -> s) -> f a -> f s
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f a
afb (s -> a
sa s
s)
{-# INLINE lens #-}

prism :: (a -> s) -> (s -> Either s a) -> Prism' s a
prism :: (a -> s) -> (s -> Either s a) -> Prism' s a
prism a -> s
bt s -> Either s a
seta = (s -> Either s a)
-> (Either s (f a) -> f s)
-> p (Either s a) (Either s (f a))
-> p s (f s)
forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap s -> Either s a
seta ((s -> f s) -> (f a -> f s) -> Either s (f a) -> f s
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either s -> f s
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((a -> s) -> f a -> f s
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> s
bt)) (p (Either s a) (Either s (f a)) -> p s (f s))
-> (p a (f a) -> p (Either s a) (Either s (f a)))
-> p a (f a)
-> p s (f s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p a (f a) -> p (Either s a) (Either s (f a))
forall (p :: * -> * -> *) a b c.
Choice p =>
p a b -> p (Either c a) (Either c b)
right'

prism' :: (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' :: (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' a -> s
bs s -> Maybe a
sma = (a -> s) -> (s -> Either s a) -> Prism' s a
forall a s. (a -> s) -> (s -> Either s a) -> Prism' s a
prism a -> s
bs (\s
s -> Either s a -> (a -> Either s a) -> Maybe a -> Either s a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (s -> Either s a
forall a b. a -> Either a b
Left s
s) a -> Either s a
forall a b. b -> Either a b
Right (s -> Maybe a
sma s
s))
{-# INLINE prism' #-}

_mtBody :: Lens' MessageText T.Text
_mtBody :: (Text -> f Text) -> MessageText -> f MessageText
_mtBody = (MessageText -> Text)
-> (MessageText -> Text -> MessageText) -> Lens' MessageText Text
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens MessageText -> Text
getter MessageText -> Text -> MessageText
setter
  where
    getter :: MessageText -> Text
getter = MessageText -> Text
mtBody
    setter :: MessageText -> Text -> MessageText
setter MessageText
mt Text
t = MessageText
mt { mtBody :: Text
mtBody = Text
t }

_mtType :: Lens' MessageText MessageTextType
_mtType :: (MessageTextType -> f MessageTextType)
-> MessageText -> f MessageText
_mtType = (MessageText -> MessageTextType)
-> (MessageText -> MessageTextType -> MessageText)
-> Lens' MessageText MessageTextType
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens MessageText -> MessageTextType
getter MessageText -> MessageTextType -> MessageText
setter
  where
    getter :: MessageText -> MessageTextType
getter = MessageText -> MessageTextType
mtType
    setter :: MessageText -> MessageTextType -> MessageText
setter MessageText
mt MessageTextType
t = MessageText
mt { mtType :: MessageTextType
mtType = MessageTextType
t }

_mtFormat :: Lens' MessageText (Maybe T.Text)
_mtFormat :: (Maybe Text -> f (Maybe Text)) -> MessageText -> f MessageText
_mtFormat = (MessageText -> Maybe Text)
-> (MessageText -> Maybe Text -> MessageText)
-> Lens' MessageText (Maybe Text)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens MessageText -> Maybe Text
getter MessageText -> Maybe Text -> MessageText
setter
  where
    getter :: MessageText -> Maybe Text
getter = MessageText -> Maybe Text
mtFormat
    setter :: MessageText -> Maybe Text -> MessageText
setter MessageText
mt Maybe Text
t = MessageText
mt { mtFormat :: Maybe Text
mtFormat = Maybe Text
t }

_mtFormattedBody :: Lens' MessageText (Maybe T.Text)
_mtFormattedBody :: (Maybe Text -> f (Maybe Text)) -> MessageText -> f MessageText
_mtFormattedBody = (MessageText -> Maybe Text)
-> (MessageText -> Maybe Text -> MessageText)
-> Lens' MessageText (Maybe Text)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens MessageText -> Maybe Text
getter MessageText -> Maybe Text -> MessageText
setter
  where
    getter :: MessageText -> Maybe Text
getter = MessageText -> Maybe Text
mtFormattedBody
    setter :: MessageText -> Maybe Text -> MessageText
setter MessageText
mt Maybe Text
t = MessageText
mt { mtFormattedBody :: Maybe Text
mtFormattedBody = Maybe Text
t}

_RoomMessageText :: Lens' RoomMessage MessageText
_RoomMessageText :: (MessageText -> f MessageText) -> RoomMessage -> f RoomMessage
_RoomMessageText = (RoomMessage -> MessageText)
-> (RoomMessage -> MessageText -> RoomMessage)
-> Lens' RoomMessage MessageText
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomMessage -> MessageText
getter RoomMessage -> MessageText -> RoomMessage
forall p. p -> MessageText -> RoomMessage
setter
  where
    getter :: RoomMessage -> MessageText
getter = RoomMessage -> MessageText
coerce
    setter :: p -> MessageText -> RoomMessage
setter p
_ MessageText
t = MessageText -> RoomMessage
RoomMessageText MessageText
t

_EventRoomMessage :: Prism' Event RoomMessage
_EventRoomMessage :: p RoomMessage (f RoomMessage) -> p Event (f Event)
_EventRoomMessage = (RoomMessage -> Event)
-> (Event -> Maybe RoomMessage) -> Prism' Event RoomMessage
forall a s. (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' RoomMessage -> Event
to Event -> Maybe RoomMessage
from
  where
    to :: RoomMessage -> Event
to = RoomMessage -> Event
EventRoomMessage
    from :: Event -> Maybe RoomMessage
from (EventRoomMessage RoomMessage
msg) = RoomMessage -> Maybe RoomMessage
forall a. a -> Maybe a
Just RoomMessage
msg
    from Event
_ = Maybe RoomMessage
forall a. Maybe a
Nothing

_EventRoomReply :: Prism' Event (EventID, RoomMessage)
_EventRoomReply :: p (EventID, RoomMessage) (f (EventID, RoomMessage))
-> p Event (f Event)
_EventRoomReply = ((EventID, RoomMessage) -> Event)
-> (Event -> Maybe (EventID, RoomMessage))
-> Prism' Event (EventID, RoomMessage)
forall a s. (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' (EventID, RoomMessage) -> Event
to Event -> Maybe (EventID, RoomMessage)
from
  where
    to :: (EventID, RoomMessage) -> Event
to (EventID
eid, RoomMessage
rm) = EventID -> RoomMessage -> Event
EventRoomReply EventID
eid RoomMessage
rm
    from :: Event -> Maybe (EventID, RoomMessage)
from (EventRoomReply EventID
eid RoomMessage
rm) = (EventID, RoomMessage) -> Maybe (EventID, RoomMessage)
forall a. a -> Maybe a
Just (EventID
eid, RoomMessage
rm)
    from Event
_ = Maybe (EventID, RoomMessage)
forall a. Maybe a
Nothing

_EventRoomEdit :: Prism' Event ((EventID, RoomMessage), RoomMessage)
_EventRoomEdit :: p ((EventID, RoomMessage), RoomMessage)
  (f ((EventID, RoomMessage), RoomMessage))
-> p Event (f Event)
_EventRoomEdit = (((EventID, RoomMessage), RoomMessage) -> Event)
-> (Event -> Maybe ((EventID, RoomMessage), RoomMessage))
-> Prism' Event ((EventID, RoomMessage), RoomMessage)
forall a s. (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' ((EventID, RoomMessage), RoomMessage) -> Event
to Event -> Maybe ((EventID, RoomMessage), RoomMessage)
from
  where
    to :: ((EventID, RoomMessage), RoomMessage) -> Event
to ((EventID, RoomMessage)
oldEvent, RoomMessage
newMsg) = (EventID, RoomMessage) -> RoomMessage -> Event
EventRoomEdit (EventID, RoomMessage)
oldEvent RoomMessage
newMsg
    from :: Event -> Maybe ((EventID, RoomMessage), RoomMessage)
from (EventRoomEdit (EventID, RoomMessage)
oldEvent RoomMessage
newMsg) = ((EventID, RoomMessage), RoomMessage)
-> Maybe ((EventID, RoomMessage), RoomMessage)
forall a. a -> Maybe a
Just ((EventID, RoomMessage)
oldEvent, RoomMessage
newMsg)
    from Event
_ = Maybe ((EventID, RoomMessage), RoomMessage)
forall a. Maybe a
Nothing

_EventUnknown :: Prism' Event J.Object
_EventUnknown :: p Object (f Object) -> p Event (f Event)
_EventUnknown = (Object -> Event) -> (Event -> Maybe Object) -> Prism' Event Object
forall a s. (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' Object -> Event
to Event -> Maybe Object
from
  where
    to :: Object -> Event
to = Object -> Event
EventUnknown
    from :: Event -> Maybe Object
from (EventUnknown Object
obj) = Object -> Maybe Object
forall a. a -> Maybe a
Just Object
obj
    from Event
_ = Maybe Object
forall a. Maybe a
Nothing

_efLimit :: Lens' EventFilter (Maybe Int)
_efLimit :: (Maybe Int -> f (Maybe Int)) -> EventFilter -> f EventFilter
_efLimit = (EventFilter -> Maybe Int)
-> (EventFilter -> Maybe Int -> EventFilter)
-> Lens' EventFilter (Maybe Int)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens EventFilter -> Maybe Int
getter EventFilter -> Maybe Int -> EventFilter
setter
  where
    getter :: EventFilter -> Maybe Int
getter = EventFilter -> Maybe Int
efLimit
    setter :: EventFilter -> Maybe Int -> EventFilter
setter EventFilter
ef Maybe Int
lim =  EventFilter
ef { efLimit :: Maybe Int
efLimit = Maybe Int
lim }

_efNotSenders :: Lens' EventFilter (Maybe [T.Text])
_efNotSenders :: (Maybe [Text] -> f (Maybe [Text])) -> EventFilter -> f EventFilter
_efNotSenders = (EventFilter -> Maybe [Text])
-> (EventFilter -> Maybe [Text] -> EventFilter)
-> Lens' EventFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens EventFilter -> Maybe [Text]
getter EventFilter -> Maybe [Text] -> EventFilter
setter
  where
    getter :: EventFilter -> Maybe [Text]
getter = EventFilter -> Maybe [Text]
efNotSenders
    setter :: EventFilter -> Maybe [Text] -> EventFilter
setter EventFilter
ef Maybe [Text]
ns = EventFilter
ef { efNotSenders :: Maybe [Text]
efNotSenders = Maybe [Text]
ns }

_efNotTypes :: Lens' EventFilter (Maybe [T.Text])
_efNotTypes :: (Maybe [Text] -> f (Maybe [Text])) -> EventFilter -> f EventFilter
_efNotTypes = (EventFilter -> Maybe [Text])
-> (EventFilter -> Maybe [Text] -> EventFilter)
-> Lens' EventFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens EventFilter -> Maybe [Text]
getter EventFilter -> Maybe [Text] -> EventFilter
setter
  where
    getter :: EventFilter -> Maybe [Text]
getter = EventFilter -> Maybe [Text]
efNotTypes
    setter :: EventFilter -> Maybe [Text] -> EventFilter
setter EventFilter
ef Maybe [Text]
nt = EventFilter
ef { efNotTypes :: Maybe [Text]
efNotTypes = Maybe [Text]
nt }

_efSenders :: Lens' EventFilter (Maybe [T.Text])
_efSenders :: (Maybe [Text] -> f (Maybe [Text])) -> EventFilter -> f EventFilter
_efSenders = (EventFilter -> Maybe [Text])
-> (EventFilter -> Maybe [Text] -> EventFilter)
-> Lens' EventFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens EventFilter -> Maybe [Text]
getter EventFilter -> Maybe [Text] -> EventFilter
setter
  where
    getter :: EventFilter -> Maybe [Text]
getter = EventFilter -> Maybe [Text]
efSenders
    setter :: EventFilter -> Maybe [Text] -> EventFilter
setter EventFilter
ef Maybe [Text]
s = EventFilter
ef { efSenders :: Maybe [Text]
efSenders = Maybe [Text]
s }

_efTypes :: Lens' EventFilter (Maybe [T.Text])
_efTypes :: (Maybe [Text] -> f (Maybe [Text])) -> EventFilter -> f EventFilter
_efTypes = (EventFilter -> Maybe [Text])
-> (EventFilter -> Maybe [Text] -> EventFilter)
-> Lens' EventFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens EventFilter -> Maybe [Text]
getter EventFilter -> Maybe [Text] -> EventFilter
setter
  where
    getter :: EventFilter -> Maybe [Text]
getter = EventFilter -> Maybe [Text]
efTypes
    setter :: EventFilter -> Maybe [Text] -> EventFilter
setter EventFilter
ef Maybe [Text]
t = EventFilter
ef { efTypes :: Maybe [Text]
efTypes = Maybe [Text]
t }

_chunk :: Lens' PaginatedRoomMessages [RoomEvent]
_chunk :: ([RoomEvent] -> f [RoomEvent])
-> PaginatedRoomMessages -> f PaginatedRoomMessages
_chunk = (PaginatedRoomMessages -> [RoomEvent])
-> (PaginatedRoomMessages -> [RoomEvent] -> PaginatedRoomMessages)
-> Lens' PaginatedRoomMessages [RoomEvent]
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens PaginatedRoomMessages -> [RoomEvent]
getter PaginatedRoomMessages -> [RoomEvent] -> PaginatedRoomMessages
setter
  where
    getter :: PaginatedRoomMessages -> [RoomEvent]
getter = PaginatedRoomMessages -> [RoomEvent]
chunk
    setter :: PaginatedRoomMessages -> [RoomEvent] -> PaginatedRoomMessages
setter PaginatedRoomMessages
prm [RoomEvent]
c = PaginatedRoomMessages
prm { chunk :: [RoomEvent]
chunk = [RoomEvent]
c }

_end :: Lens' PaginatedRoomMessages (Maybe T.Text)
_end :: (Maybe Text -> f (Maybe Text))
-> PaginatedRoomMessages -> f PaginatedRoomMessages
_end = (PaginatedRoomMessages -> Maybe Text)
-> (PaginatedRoomMessages -> Maybe Text -> PaginatedRoomMessages)
-> Lens' PaginatedRoomMessages (Maybe Text)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens PaginatedRoomMessages -> Maybe Text
getter PaginatedRoomMessages -> Maybe Text -> PaginatedRoomMessages
setter
  where
    getter :: PaginatedRoomMessages -> Maybe Text
getter = PaginatedRoomMessages -> Maybe Text
end
    setter :: PaginatedRoomMessages -> Maybe Text -> PaginatedRoomMessages
setter PaginatedRoomMessages
prm Maybe Text
e = PaginatedRoomMessages
prm { end :: Maybe Text
end = Maybe Text
e }

_start :: Lens' PaginatedRoomMessages T.Text
_start :: (Text -> f Text)
-> PaginatedRoomMessages -> f PaginatedRoomMessages
_start = (PaginatedRoomMessages -> Text)
-> (PaginatedRoomMessages -> Text -> PaginatedRoomMessages)
-> Lens' PaginatedRoomMessages Text
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens PaginatedRoomMessages -> Text
getter PaginatedRoomMessages -> Text -> PaginatedRoomMessages
setter
  where
    getter :: PaginatedRoomMessages -> Text
getter = PaginatedRoomMessages -> Text
start
    setter :: PaginatedRoomMessages -> Text -> PaginatedRoomMessages
setter PaginatedRoomMessages
prm Text
s = PaginatedRoomMessages
prm { start :: Text
start = Text
s }

_state :: Lens' PaginatedRoomMessages [StateEvent]
_state :: ([StateEvent] -> f [StateEvent])
-> PaginatedRoomMessages -> f PaginatedRoomMessages
_state = (PaginatedRoomMessages -> [StateEvent])
-> (PaginatedRoomMessages -> [StateEvent] -> PaginatedRoomMessages)
-> Lens' PaginatedRoomMessages [StateEvent]
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens PaginatedRoomMessages -> [StateEvent]
getter PaginatedRoomMessages -> [StateEvent] -> PaginatedRoomMessages
setter
  where
    getter :: PaginatedRoomMessages -> [StateEvent]
getter = PaginatedRoomMessages -> [StateEvent]
state
    setter :: PaginatedRoomMessages -> [StateEvent] -> PaginatedRoomMessages
setter PaginatedRoomMessages
prm [StateEvent]
s = PaginatedRoomMessages
prm { state :: [StateEvent]
state = [StateEvent]
s }

_roomAlias :: Lens' ResolvedRoomAlias RoomAlias
_roomAlias :: (RoomAlias -> f RoomAlias)
-> ResolvedRoomAlias -> f ResolvedRoomAlias
_roomAlias = (ResolvedRoomAlias -> RoomAlias)
-> (ResolvedRoomAlias -> RoomAlias -> ResolvedRoomAlias)
-> Lens' ResolvedRoomAlias RoomAlias
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens ResolvedRoomAlias -> RoomAlias
getter ResolvedRoomAlias -> RoomAlias -> ResolvedRoomAlias
setter
  where
    getter :: ResolvedRoomAlias -> RoomAlias
getter = ResolvedRoomAlias -> RoomAlias
roomAlias
    setter :: ResolvedRoomAlias -> RoomAlias -> ResolvedRoomAlias
setter ResolvedRoomAlias
rra RoomAlias
ra = ResolvedRoomAlias
rra { roomAlias :: RoomAlias
roomAlias = RoomAlias
ra }

_roomID :: Lens' ResolvedRoomAlias RoomID
_roomID :: (RoomID -> f RoomID) -> ResolvedRoomAlias -> f ResolvedRoomAlias
_roomID = (ResolvedRoomAlias -> RoomID)
-> (ResolvedRoomAlias -> RoomID -> ResolvedRoomAlias)
-> Lens' ResolvedRoomAlias RoomID
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens ResolvedRoomAlias -> RoomID
getter ResolvedRoomAlias -> RoomID -> ResolvedRoomAlias
setter
  where
    getter :: ResolvedRoomAlias -> RoomID
getter = ResolvedRoomAlias -> RoomID
roomID
    setter :: ResolvedRoomAlias -> RoomID -> ResolvedRoomAlias
setter ResolvedRoomAlias
rra RoomID
rid = ResolvedRoomAlias
rra { roomID :: RoomID
roomID = RoomID
rid }

_servers :: Lens' ResolvedRoomAlias [T.Text]
_servers :: ([Text] -> f [Text]) -> ResolvedRoomAlias -> f ResolvedRoomAlias
_servers = (ResolvedRoomAlias -> [Text])
-> (ResolvedRoomAlias -> [Text] -> ResolvedRoomAlias)
-> Lens' ResolvedRoomAlias [Text]
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens ResolvedRoomAlias -> [Text]
getter ResolvedRoomAlias -> [Text] -> ResolvedRoomAlias
setter
  where
    getter :: ResolvedRoomAlias -> [Text]
getter = ResolvedRoomAlias -> [Text]
servers
    setter :: ResolvedRoomAlias -> [Text] -> ResolvedRoomAlias
setter ResolvedRoomAlias
rra [Text]
s = ResolvedRoomAlias
rra { servers :: [Text]
servers = [Text]
s }

_refLimit :: Lens' RoomEventFilter (Maybe Int)
_refLimit :: (Maybe Int -> f (Maybe Int))
-> RoomEventFilter -> f RoomEventFilter
_refLimit = (RoomEventFilter -> Maybe Int)
-> (RoomEventFilter -> Maybe Int -> RoomEventFilter)
-> Lens' RoomEventFilter (Maybe Int)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEventFilter -> Maybe Int
getter RoomEventFilter -> Maybe Int -> RoomEventFilter
setter
  where
    getter :: RoomEventFilter -> Maybe Int
getter = RoomEventFilter -> Maybe Int
refLimit
    setter :: RoomEventFilter -> Maybe Int -> RoomEventFilter
setter RoomEventFilter
ref Maybe Int
rl = RoomEventFilter
ref { refLimit :: Maybe Int
refLimit = Maybe Int
rl }

_refNotSenders :: Lens' RoomEventFilter (Maybe [T.Text])
_refNotSenders :: (Maybe [Text] -> f (Maybe [Text]))
-> RoomEventFilter -> f RoomEventFilter
_refNotSenders = (RoomEventFilter -> Maybe [Text])
-> (RoomEventFilter -> Maybe [Text] -> RoomEventFilter)
-> Lens' RoomEventFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEventFilter -> Maybe [Text]
getter RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter
  where
    getter :: RoomEventFilter -> Maybe [Text]
getter = RoomEventFilter -> Maybe [Text]
refNotSenders
    setter :: RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter RoomEventFilter
ref Maybe [Text]
ns = RoomEventFilter
ref { refNotSenders :: Maybe [Text]
refNotSenders = Maybe [Text]
ns }

_refNotTypes :: Lens' RoomEventFilter (Maybe [T.Text])
_refNotTypes :: (Maybe [Text] -> f (Maybe [Text]))
-> RoomEventFilter -> f RoomEventFilter
_refNotTypes = (RoomEventFilter -> Maybe [Text])
-> (RoomEventFilter -> Maybe [Text] -> RoomEventFilter)
-> Lens' RoomEventFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEventFilter -> Maybe [Text]
getter RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter
  where
    getter :: RoomEventFilter -> Maybe [Text]
getter = RoomEventFilter -> Maybe [Text]
refNotTypes
    setter :: RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter RoomEventFilter
ref Maybe [Text]
rnt = RoomEventFilter
ref { refNotTypes :: Maybe [Text]
refNotTypes = Maybe [Text]
rnt }

_refSenders :: Lens' RoomEventFilter (Maybe [T.Text])
_refSenders :: (Maybe [Text] -> f (Maybe [Text]))
-> RoomEventFilter -> f RoomEventFilter
_refSenders = (RoomEventFilter -> Maybe [Text])
-> (RoomEventFilter -> Maybe [Text] -> RoomEventFilter)
-> Lens' RoomEventFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEventFilter -> Maybe [Text]
getter RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter
 where
   getter :: RoomEventFilter -> Maybe [Text]
getter = RoomEventFilter -> Maybe [Text]
refSenders
   setter :: RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter RoomEventFilter
ref Maybe [Text]
rs = RoomEventFilter
ref { refSenders :: Maybe [Text]
refSenders = Maybe [Text]
rs }

_refTypes :: Lens' RoomEventFilter (Maybe [T.Text])
_refTypes :: (Maybe [Text] -> f (Maybe [Text]))
-> RoomEventFilter -> f RoomEventFilter
_refTypes = (RoomEventFilter -> Maybe [Text])
-> (RoomEventFilter -> Maybe [Text] -> RoomEventFilter)
-> Lens' RoomEventFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEventFilter -> Maybe [Text]
getter RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter
  where
    getter :: RoomEventFilter -> Maybe [Text]
getter = RoomEventFilter -> Maybe [Text]
refTypes
    setter :: RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter RoomEventFilter
ref Maybe [Text]
rt = RoomEventFilter
ref { refTypes :: Maybe [Text]
refTypes = Maybe [Text]
rt }

_refLazyLoadMembers :: Lens' RoomEventFilter (Maybe Bool)
_refLazyLoadMembers :: (Maybe Bool -> f (Maybe Bool))
-> RoomEventFilter -> f RoomEventFilter
_refLazyLoadMembers = (RoomEventFilter -> Maybe Bool)
-> (RoomEventFilter -> Maybe Bool -> RoomEventFilter)
-> Lens' RoomEventFilter (Maybe Bool)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEventFilter -> Maybe Bool
getter RoomEventFilter -> Maybe Bool -> RoomEventFilter
setter
  where
    getter :: RoomEventFilter -> Maybe Bool
getter = RoomEventFilter -> Maybe Bool
refLazyLoadMembers
    setter :: RoomEventFilter -> Maybe Bool -> RoomEventFilter
setter RoomEventFilter
ref Maybe Bool
rldm = RoomEventFilter
ref { refLazyLoadMembers :: Maybe Bool
refLazyLoadMembers = Maybe Bool
rldm }

_refIncludeRedundantMembers :: Lens' RoomEventFilter (Maybe Bool)
_refIncludeRedundantMembers :: (Maybe Bool -> f (Maybe Bool))
-> RoomEventFilter -> f RoomEventFilter
_refIncludeRedundantMembers = (RoomEventFilter -> Maybe Bool)
-> (RoomEventFilter -> Maybe Bool -> RoomEventFilter)
-> Lens' RoomEventFilter (Maybe Bool)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEventFilter -> Maybe Bool
getter RoomEventFilter -> Maybe Bool -> RoomEventFilter
setter
  where
    getter :: RoomEventFilter -> Maybe Bool
getter = RoomEventFilter -> Maybe Bool
refIncludeRedundantMembers
    setter :: RoomEventFilter -> Maybe Bool -> RoomEventFilter
setter RoomEventFilter
ref Maybe Bool
rirm = RoomEventFilter
ref { refIncludeRedundantMembers :: Maybe Bool
refIncludeRedundantMembers = Maybe Bool
rirm }

_refNotRooms :: Lens' RoomEventFilter (Maybe [T.Text])
_refNotRooms :: (Maybe [Text] -> f (Maybe [Text]))
-> RoomEventFilter -> f RoomEventFilter
_refNotRooms = (RoomEventFilter -> Maybe [Text])
-> (RoomEventFilter -> Maybe [Text] -> RoomEventFilter)
-> Lens' RoomEventFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEventFilter -> Maybe [Text]
getter RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter
  where
    getter :: RoomEventFilter -> Maybe [Text]
getter = RoomEventFilter -> Maybe [Text]
refNotRooms
    setter :: RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter RoomEventFilter
ref Maybe [Text]
rnr = RoomEventFilter
ref { refNotRooms :: Maybe [Text]
refNotRooms = Maybe [Text]
rnr }

_refRooms :: Lens' RoomEventFilter (Maybe [T.Text])
_refRooms :: (Maybe [Text] -> f (Maybe [Text]))
-> RoomEventFilter -> f RoomEventFilter
_refRooms = (RoomEventFilter -> Maybe [Text])
-> (RoomEventFilter -> Maybe [Text] -> RoomEventFilter)
-> Lens' RoomEventFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEventFilter -> Maybe [Text]
getter RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter
  where
    getter :: RoomEventFilter -> Maybe [Text]
getter = RoomEventFilter -> Maybe [Text]
refRooms
    setter :: RoomEventFilter -> Maybe [Text] -> RoomEventFilter
setter RoomEventFilter
ref Maybe [Text]
rr = RoomEventFilter
ref { refRooms :: Maybe [Text]
refRooms = Maybe [Text]
rr }

_refContainsUrl :: Lens' RoomEventFilter (Maybe Bool)
_refContainsUrl :: (Maybe Bool -> f (Maybe Bool))
-> RoomEventFilter -> f RoomEventFilter
_refContainsUrl = (RoomEventFilter -> Maybe Bool)
-> (RoomEventFilter -> Maybe Bool -> RoomEventFilter)
-> Lens' RoomEventFilter (Maybe Bool)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEventFilter -> Maybe Bool
getter RoomEventFilter -> Maybe Bool -> RoomEventFilter
setter
  where
    getter :: RoomEventFilter -> Maybe Bool
getter = RoomEventFilter -> Maybe Bool
refContainsUrl
    setter :: RoomEventFilter -> Maybe Bool -> RoomEventFilter
setter RoomEventFilter
ref Maybe Bool
rcu = RoomEventFilter
ref { refContainsUrl :: Maybe Bool
refContainsUrl = Maybe Bool
rcu }

_StateContentMRCreate :: Prism' StateContent MRCreate
_StateContentMRCreate :: p MRCreate (f MRCreate) -> p StateContent (f StateContent)
_StateContentMRCreate = (MRCreate -> StateContent)
-> (StateContent -> Maybe MRCreate) -> Prism' StateContent MRCreate
forall a s. (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' MRCreate -> StateContent
to StateContent -> Maybe MRCreate
from
  where
    to :: MRCreate -> StateContent
to = MRCreate -> StateContent
StRoomCreate
    from :: StateContent -> Maybe MRCreate
from (StRoomCreate MRCreate
create) = MRCreate -> Maybe MRCreate
forall a. a -> Maybe a
Just MRCreate
create
    from StateContent
_ = Maybe MRCreate
forall a. Maybe a
Nothing

_StateContentMRCanonicalAlias :: Prism' StateContent MRCanonicalAlias
_StateContentMRCanonicalAlias :: p MRCanonicalAlias (f MRCanonicalAlias)
-> p StateContent (f StateContent)
_StateContentMRCanonicalAlias = (MRCanonicalAlias -> StateContent)
-> (StateContent -> Maybe MRCanonicalAlias)
-> Prism' StateContent MRCanonicalAlias
forall a s. (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' MRCanonicalAlias -> StateContent
to StateContent -> Maybe MRCanonicalAlias
from
  where
    to :: MRCanonicalAlias -> StateContent
to = MRCanonicalAlias -> StateContent
StRoomCanonicalAlias
    from :: StateContent -> Maybe MRCanonicalAlias
from (StRoomCanonicalAlias MRCanonicalAlias
alias) = MRCanonicalAlias -> Maybe MRCanonicalAlias
forall a. a -> Maybe a
Just MRCanonicalAlias
alias
    from StateContent
_ = Maybe MRCanonicalAlias
forall a. Maybe a
Nothing

_StateContentMRGuestAccess :: Prism' StateContent MRGuestAccess
_StateContentMRGuestAccess :: p MRGuestAccess (f MRGuestAccess)
-> p StateContent (f StateContent)
_StateContentMRGuestAccess = (MRGuestAccess -> StateContent)
-> (StateContent -> Maybe MRGuestAccess)
-> Prism' StateContent MRGuestAccess
forall a s. (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' MRGuestAccess -> StateContent
to StateContent -> Maybe MRGuestAccess
from
  where
    to :: MRGuestAccess -> StateContent
to = MRGuestAccess -> StateContent
StRoomGuestAccess
    from :: StateContent -> Maybe MRGuestAccess
from (StRoomGuestAccess MRGuestAccess
guest) = MRGuestAccess -> Maybe MRGuestAccess
forall a. a -> Maybe a
Just MRGuestAccess
guest
    from StateContent
_ = Maybe MRGuestAccess
forall a. Maybe a
Nothing

_StateContentMRHistoryVisibility :: Prism' StateContent MRHistoryVisibility
_StateContentMRHistoryVisibility :: p MRHistoryVisibility (f MRHistoryVisibility)
-> p StateContent (f StateContent)
_StateContentMRHistoryVisibility = (MRHistoryVisibility -> StateContent)
-> (StateContent -> Maybe MRHistoryVisibility)
-> Prism' StateContent MRHistoryVisibility
forall a s. (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' MRHistoryVisibility -> StateContent
to StateContent -> Maybe MRHistoryVisibility
from
  where
    to :: MRHistoryVisibility -> StateContent
to = MRHistoryVisibility -> StateContent
StRoomHistoryVisibility
    from :: StateContent -> Maybe MRHistoryVisibility
from (StRoomHistoryVisibility MRHistoryVisibility
history) = MRHistoryVisibility -> Maybe MRHistoryVisibility
forall a. a -> Maybe a
Just MRHistoryVisibility
history
    from StateContent
_ = Maybe MRHistoryVisibility
forall a. Maybe a
Nothing

_StateContentMRName :: Prism' StateContent MRName
_StateContentMRName :: p MRName (f MRName) -> p StateContent (f StateContent)
_StateContentMRName = (MRName -> StateContent)
-> (StateContent -> Maybe MRName) -> Prism' StateContent MRName
forall a s. (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' MRName -> StateContent
to StateContent -> Maybe MRName
from
  where
    to :: MRName -> StateContent
to = MRName -> StateContent
StRoomName
    from :: StateContent -> Maybe MRName
from (StRoomName MRName
name) = MRName -> Maybe MRName
forall a. a -> Maybe a
Just MRName
name
    from StateContent
_ = Maybe MRName
forall a. Maybe a
Nothing

_StateContentMRTopic :: Prism' StateContent MRTopic
_StateContentMRTopic :: p MRTopic (f MRTopic) -> p StateContent (f StateContent)
_StateContentMRTopic = (MRTopic -> StateContent)
-> (StateContent -> Maybe MRTopic) -> Prism' StateContent MRTopic
forall a s. (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' MRTopic -> StateContent
to StateContent -> Maybe MRTopic
from
  where
    to :: MRTopic -> StateContent
to = MRTopic -> StateContent
StRoomTopic
    from :: StateContent -> Maybe MRTopic
from (StRoomTopic MRTopic
topic) = MRTopic -> Maybe MRTopic
forall a. a -> Maybe a
Just MRTopic
topic
    from StateContent
_ = Maybe MRTopic
forall a. Maybe a
Nothing

_StateContentMROther :: Prism' StateContent J.Value
_StateContentMROther :: p Value (f Value) -> p StateContent (f StateContent)
_StateContentMROther = (Value -> StateContent)
-> (StateContent -> Maybe Value) -> Prism' StateContent Value
forall a s. (a -> s) -> (s -> Maybe a) -> Prism' s a
prism' Value -> StateContent
to StateContent -> Maybe Value
from
  where
    to :: Value -> StateContent
to = Value -> StateContent
StOther
    from :: StateContent -> Maybe Value
from (StOther Value
other) = Value -> Maybe Value
forall a. a -> Maybe a
Just Value
other
    from StateContent
_ = Maybe Value
forall a. Maybe a
Nothing

_seContent :: Lens' StateEvent StateContent
_seContent :: (StateContent -> f StateContent) -> StateEvent -> f StateEvent
_seContent = (StateEvent -> StateContent)
-> (StateEvent -> StateContent -> StateEvent)
-> Lens' StateEvent StateContent
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateEvent -> StateContent
getter StateEvent -> StateContent -> StateEvent
setter
  where
    getter :: StateEvent -> StateContent
getter = StateEvent -> StateContent
seContent
    setter :: StateEvent -> StateContent -> StateEvent
setter StateEvent
sec StateContent
c = StateEvent
sec { seContent :: StateContent
seContent = StateContent
c }

_seEventId :: Lens' StateEvent EventID
_seEventId :: (EventID -> f EventID) -> StateEvent -> f StateEvent
_seEventId = (StateEvent -> EventID)
-> (StateEvent -> EventID -> StateEvent)
-> Lens' StateEvent EventID
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateEvent -> EventID
getter StateEvent -> EventID -> StateEvent
setter
  where
    getter :: StateEvent -> EventID
getter = StateEvent -> EventID
seEventId
    setter :: StateEvent -> EventID -> StateEvent
setter StateEvent
sec EventID
eid = StateEvent
sec { seEventId :: EventID
seEventId = EventID
eid }

_seOriginServerTimestamp :: Lens' StateEvent Integer
_seOriginServerTimestamp :: (Integer -> f Integer) -> StateEvent -> f StateEvent
_seOriginServerTimestamp = (StateEvent -> Integer)
-> (StateEvent -> Integer -> StateEvent)
-> Lens' StateEvent Integer
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateEvent -> Integer
getter StateEvent -> Integer -> StateEvent
setter
  where
    getter :: StateEvent -> Integer
getter = StateEvent -> Integer
seOriginServerTimestamp
    setter :: StateEvent -> Integer -> StateEvent
setter StateEvent
sec Integer
ts = StateEvent
sec { seOriginServerTimestamp :: Integer
seOriginServerTimestamp = Integer
ts }

_sePreviousContent :: Lens' StateEvent (Maybe J.Value)
_sePreviousContent :: (Maybe Value -> f (Maybe Value)) -> StateEvent -> f StateEvent
_sePreviousContent = (StateEvent -> Maybe Value)
-> (StateEvent -> Maybe Value -> StateEvent)
-> Lens' StateEvent (Maybe Value)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateEvent -> Maybe Value
getter StateEvent -> Maybe Value -> StateEvent
setter
  where
    getter :: StateEvent -> Maybe Value
getter = StateEvent -> Maybe Value
sePreviousContent
    setter :: StateEvent -> Maybe Value -> StateEvent
setter StateEvent
sec Maybe Value
c = StateEvent
sec { sePreviousContent :: Maybe Value
sePreviousContent = Maybe Value
c }

_seRoomId :: Lens' StateEvent RoomID
_seRoomId :: (RoomID -> f RoomID) -> StateEvent -> f StateEvent
_seRoomId = (StateEvent -> RoomID)
-> (StateEvent -> RoomID -> StateEvent) -> Lens' StateEvent RoomID
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateEvent -> RoomID
getter StateEvent -> RoomID -> StateEvent
setter
  where
    getter :: StateEvent -> RoomID
getter = StateEvent -> RoomID
seRoomId
    setter :: StateEvent -> RoomID -> StateEvent
setter StateEvent
sec RoomID
rid = StateEvent
sec { seRoomId :: RoomID
seRoomId = RoomID
rid }

_seSender :: Lens' StateEvent UserID
_seSender :: (UserID -> f UserID) -> StateEvent -> f StateEvent
_seSender = (StateEvent -> UserID)
-> (StateEvent -> UserID -> StateEvent) -> Lens' StateEvent UserID
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateEvent -> UserID
getter StateEvent -> UserID -> StateEvent
setter
  where
    getter :: StateEvent -> UserID
getter = StateEvent -> UserID
seSender
    setter :: StateEvent -> UserID -> StateEvent
setter StateEvent
sec UserID
uid = StateEvent
sec { seSender :: UserID
seSender = UserID
uid }

_seStateKey :: Lens' StateEvent StateKey
_seStateKey :: (StateKey -> f StateKey) -> StateEvent -> f StateEvent
_seStateKey = (StateEvent -> StateKey)
-> (StateEvent -> StateKey -> StateEvent)
-> Lens' StateEvent StateKey
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateEvent -> StateKey
getter StateEvent -> StateKey -> StateEvent
setter
  where
    getter :: StateEvent -> StateKey
getter = StateEvent -> StateKey
seStateKey
    setter :: StateEvent -> StateKey -> StateEvent
setter StateEvent
sec StateKey
key = StateEvent
sec { seStateKey :: StateKey
seStateKey = StateKey
key }

_seEventType :: Lens' StateEvent EventType
_seEventType :: (EventType -> f EventType) -> StateEvent -> f StateEvent
_seEventType = (StateEvent -> EventType)
-> (StateEvent -> EventType -> StateEvent)
-> Lens' StateEvent EventType
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateEvent -> EventType
getter StateEvent -> EventType -> StateEvent
setter
  where
    getter :: StateEvent -> EventType
getter = StateEvent -> EventType
seEventType
    setter :: StateEvent -> EventType -> StateEvent
setter StateEvent
sec EventType
et = StateEvent
sec { seEventType :: EventType
seEventType = EventType
et }

_seUnsigned :: Lens' StateEvent (Maybe J.Value)
_seUnsigned :: (Maybe Value -> f (Maybe Value)) -> StateEvent -> f StateEvent
_seUnsigned = (StateEvent -> Maybe Value)
-> (StateEvent -> Maybe Value -> StateEvent)
-> Lens' StateEvent (Maybe Value)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateEvent -> Maybe Value
getter StateEvent -> Maybe Value -> StateEvent
setter
  where
    getter :: StateEvent -> Maybe Value
getter = StateEvent -> Maybe Value
seUnsigned
    setter :: StateEvent -> Maybe Value -> StateEvent
setter StateEvent
sec Maybe Value
val = StateEvent
sec { seUnsigned :: Maybe Value
seUnsigned = Maybe Value
val }

_sfLimit :: Lens' StateFilter (Maybe Int)
_sfLimit :: (Maybe Int -> f (Maybe Int)) -> StateFilter -> f StateFilter
_sfLimit = (StateFilter -> Maybe Int)
-> (StateFilter -> Maybe Int -> StateFilter)
-> Lens' StateFilter (Maybe Int)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateFilter -> Maybe Int
getter StateFilter -> Maybe Int -> StateFilter
setter
  where
    getter :: StateFilter -> Maybe Int
getter = StateFilter -> Maybe Int
sfLimit
    setter :: StateFilter -> Maybe Int -> StateFilter
setter StateFilter
sf Maybe Int
sfl = StateFilter
sf { sfLimit :: Maybe Int
sfLimit = Maybe Int
sfl }

_sfNotSenders :: Lens' StateFilter (Maybe [T.Text])
_sfNotSenders :: (Maybe [Text] -> f (Maybe [Text])) -> StateFilter -> f StateFilter
_sfNotSenders = (StateFilter -> Maybe [Text])
-> (StateFilter -> Maybe [Text] -> StateFilter)
-> Lens' StateFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateFilter -> Maybe [Text]
getter StateFilter -> Maybe [Text] -> StateFilter
setter
  where
    getter :: StateFilter -> Maybe [Text]
getter = StateFilter -> Maybe [Text]
sfNotSenders
    setter :: StateFilter -> Maybe [Text] -> StateFilter
setter StateFilter
sf Maybe [Text]
sfns = StateFilter
sf { sfNotSenders :: Maybe [Text]
sfNotSenders = Maybe [Text]
sfns}

_sfTypes :: Lens' StateFilter (Maybe [T.Text])
_sfTypes :: (Maybe [Text] -> f (Maybe [Text])) -> StateFilter -> f StateFilter
_sfTypes = (StateFilter -> Maybe [Text])
-> (StateFilter -> Maybe [Text] -> StateFilter)
-> Lens' StateFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateFilter -> Maybe [Text]
getter StateFilter -> Maybe [Text] -> StateFilter
setter
  where
    getter :: StateFilter -> Maybe [Text]
getter = StateFilter -> Maybe [Text]
sfTypes
    setter :: StateFilter -> Maybe [Text] -> StateFilter
setter StateFilter
sf Maybe [Text]
sft = StateFilter
sf { sfTypes :: Maybe [Text]
sfTypes = Maybe [Text]
sft }

_sfLazyLoadMembers :: Lens' StateFilter (Maybe Bool)
_sfLazyLoadMembers :: (Maybe Bool -> f (Maybe Bool)) -> StateFilter -> f StateFilter
_sfLazyLoadMembers = (StateFilter -> Maybe Bool)
-> (StateFilter -> Maybe Bool -> StateFilter)
-> Lens' StateFilter (Maybe Bool)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateFilter -> Maybe Bool
getter StateFilter -> Maybe Bool -> StateFilter
setter
  where
    getter :: StateFilter -> Maybe Bool
getter = StateFilter -> Maybe Bool
sfLazyLoadMembers
    setter :: StateFilter -> Maybe Bool -> StateFilter
setter StateFilter
sf Maybe Bool
sflm = StateFilter
sf { sfLazyLoadMembers :: Maybe Bool
sfLazyLoadMembers = Maybe Bool
sflm }

_sfIncludeRedundantMembers :: Lens' StateFilter (Maybe Bool)
_sfIncludeRedundantMembers :: (Maybe Bool -> f (Maybe Bool)) -> StateFilter -> f StateFilter
_sfIncludeRedundantMembers = (StateFilter -> Maybe Bool)
-> (StateFilter -> Maybe Bool -> StateFilter)
-> Lens' StateFilter (Maybe Bool)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateFilter -> Maybe Bool
getter StateFilter -> Maybe Bool -> StateFilter
setter
  where
    getter :: StateFilter -> Maybe Bool
getter = StateFilter -> Maybe Bool
sfIncludeRedundantMembers
    setter :: StateFilter -> Maybe Bool -> StateFilter
setter StateFilter
sf Maybe Bool
sfirm = StateFilter
sf { sfIncludeRedundantMembers :: Maybe Bool
sfIncludeRedundantMembers = Maybe Bool
sfirm }

_sfNotRooms :: Lens' StateFilter (Maybe [T.Text])
_sfNotRooms :: (Maybe [Text] -> f (Maybe [Text])) -> StateFilter -> f StateFilter
_sfNotRooms = (StateFilter -> Maybe [Text])
-> (StateFilter -> Maybe [Text] -> StateFilter)
-> Lens' StateFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateFilter -> Maybe [Text]
getter StateFilter -> Maybe [Text] -> StateFilter
setter
  where
    getter :: StateFilter -> Maybe [Text]
getter = StateFilter -> Maybe [Text]
sfNotRooms
    setter :: StateFilter -> Maybe [Text] -> StateFilter
setter StateFilter
sf Maybe [Text]
sfnr = StateFilter
sf { sfNotRooms :: Maybe [Text]
sfNotRooms = Maybe [Text]
sfnr }

_sfRooms :: Lens' StateFilter (Maybe [T.Text])
_sfRooms :: (Maybe [Text] -> f (Maybe [Text])) -> StateFilter -> f StateFilter
_sfRooms = (StateFilter -> Maybe [Text])
-> (StateFilter -> Maybe [Text] -> StateFilter)
-> Lens' StateFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateFilter -> Maybe [Text]
getter StateFilter -> Maybe [Text] -> StateFilter
setter
  where
    getter :: StateFilter -> Maybe [Text]
getter = StateFilter -> Maybe [Text]
sfRooms
    setter :: StateFilter -> Maybe [Text] -> StateFilter
setter StateFilter
sf Maybe [Text]
sfr = StateFilter
sf { sfRooms :: Maybe [Text]
sfRooms = Maybe [Text]
sfr }

_sfContainsUrl :: Lens' StateFilter (Maybe Bool)
_sfContainsUrl :: (Maybe Bool -> f (Maybe Bool)) -> StateFilter -> f StateFilter
_sfContainsUrl = (StateFilter -> Maybe Bool)
-> (StateFilter -> Maybe Bool -> StateFilter)
-> Lens' StateFilter (Maybe Bool)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens StateFilter -> Maybe Bool
getter StateFilter -> Maybe Bool -> StateFilter
setter
  where
    getter :: StateFilter -> Maybe Bool
getter = StateFilter -> Maybe Bool
sfContains_url
    setter :: StateFilter -> Maybe Bool -> StateFilter
setter StateFilter
sf Maybe Bool
cu = StateFilter
sf { sfContains_url :: Maybe Bool
sfContains_url = Maybe Bool
cu }

_rfNotRooms :: Lens' RoomFilter (Maybe [T.Text])
_rfNotRooms :: (Maybe [Text] -> f (Maybe [Text])) -> RoomFilter -> f RoomFilter
_rfNotRooms = (RoomFilter -> Maybe [Text])
-> (RoomFilter -> Maybe [Text] -> RoomFilter)
-> Lens' RoomFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomFilter -> Maybe [Text]
getter RoomFilter -> Maybe [Text] -> RoomFilter
setter
  where
    getter :: RoomFilter -> Maybe [Text]
getter = RoomFilter -> Maybe [Text]
rfNotRooms
    setter :: RoomFilter -> Maybe [Text] -> RoomFilter
setter RoomFilter
rm Maybe [Text]
rfnr = RoomFilter
rm { rfNotRooms :: Maybe [Text]
rfNotRooms = Maybe [Text]
rfnr }

_rfRooms :: Lens' RoomFilter (Maybe [T.Text])
_rfRooms :: (Maybe [Text] -> f (Maybe [Text])) -> RoomFilter -> f RoomFilter
_rfRooms = (RoomFilter -> Maybe [Text])
-> (RoomFilter -> Maybe [Text] -> RoomFilter)
-> Lens' RoomFilter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomFilter -> Maybe [Text]
getter RoomFilter -> Maybe [Text] -> RoomFilter
setter
  where
    getter :: RoomFilter -> Maybe [Text]
getter = RoomFilter -> Maybe [Text]
rfRooms
    setter :: RoomFilter -> Maybe [Text] -> RoomFilter
setter RoomFilter
rm Maybe [Text]
rfr = RoomFilter
rm { rfRooms :: Maybe [Text]
rfRooms = Maybe [Text]
rfr }

_rfEphemeral :: Lens' RoomFilter (Maybe RoomEventFilter)
_rfEphemeral :: (Maybe RoomEventFilter -> f (Maybe RoomEventFilter))
-> RoomFilter -> f RoomFilter
_rfEphemeral = (RoomFilter -> Maybe RoomEventFilter)
-> (RoomFilter -> Maybe RoomEventFilter -> RoomFilter)
-> Lens' RoomFilter (Maybe RoomEventFilter)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomFilter -> Maybe RoomEventFilter
getter RoomFilter -> Maybe RoomEventFilter -> RoomFilter
setter
  where
    getter :: RoomFilter -> Maybe RoomEventFilter
getter = RoomFilter -> Maybe RoomEventFilter
rfEphemeral
    setter :: RoomFilter -> Maybe RoomEventFilter -> RoomFilter
setter RoomFilter
rm Maybe RoomEventFilter
rfe = RoomFilter
rm { rfEphemeral :: Maybe RoomEventFilter
rfEphemeral = Maybe RoomEventFilter
rfe }

_rfIncludeLeave :: Lens' RoomFilter (Maybe Bool)
_rfIncludeLeave :: (Maybe Bool -> f (Maybe Bool)) -> RoomFilter -> f RoomFilter
_rfIncludeLeave = (RoomFilter -> Maybe Bool)
-> (RoomFilter -> Maybe Bool -> RoomFilter)
-> Lens' RoomFilter (Maybe Bool)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomFilter -> Maybe Bool
getter RoomFilter -> Maybe Bool -> RoomFilter
setter
  where
    getter :: RoomFilter -> Maybe Bool
getter = RoomFilter -> Maybe Bool
rfIncludeLeave
    setter :: RoomFilter -> Maybe Bool -> RoomFilter
setter RoomFilter
rm Maybe Bool
rfil = RoomFilter
rm { rfIncludeLeave :: Maybe Bool
rfIncludeLeave = Maybe Bool
rfil }

_rfState :: Lens' RoomFilter (Maybe StateFilter)
_rfState :: (Maybe StateFilter -> f (Maybe StateFilter))
-> RoomFilter -> f RoomFilter
_rfState = (RoomFilter -> Maybe StateFilter)
-> (RoomFilter -> Maybe StateFilter -> RoomFilter)
-> Lens' RoomFilter (Maybe StateFilter)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomFilter -> Maybe StateFilter
getter RoomFilter -> Maybe StateFilter -> RoomFilter
setter
  where
    getter :: RoomFilter -> Maybe StateFilter
getter = RoomFilter -> Maybe StateFilter
rfState
    setter :: RoomFilter -> Maybe StateFilter -> RoomFilter
setter RoomFilter
rm Maybe StateFilter
rfs = RoomFilter
rm { rfState :: Maybe StateFilter
rfState = Maybe StateFilter
rfs }

_rfTimeline :: Lens' RoomFilter (Maybe RoomEventFilter)
_rfTimeline :: (Maybe RoomEventFilter -> f (Maybe RoomEventFilter))
-> RoomFilter -> f RoomFilter
_rfTimeline = (RoomFilter -> Maybe RoomEventFilter)
-> (RoomFilter -> Maybe RoomEventFilter -> RoomFilter)
-> Lens' RoomFilter (Maybe RoomEventFilter)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomFilter -> Maybe RoomEventFilter
getter RoomFilter -> Maybe RoomEventFilter -> RoomFilter
setter
  where
    getter :: RoomFilter -> Maybe RoomEventFilter
getter = RoomFilter -> Maybe RoomEventFilter
rfTimeline
    setter :: RoomFilter -> Maybe RoomEventFilter -> RoomFilter
setter RoomFilter
rm Maybe RoomEventFilter
rft = RoomFilter
rm { rfTimeline :: Maybe RoomEventFilter
rfTimeline = Maybe RoomEventFilter
rft }

_rfAccountData :: Lens' RoomFilter (Maybe RoomEventFilter)
_rfAccountData :: (Maybe RoomEventFilter -> f (Maybe RoomEventFilter))
-> RoomFilter -> f RoomFilter
_rfAccountData = (RoomFilter -> Maybe RoomEventFilter)
-> (RoomFilter -> Maybe RoomEventFilter -> RoomFilter)
-> Lens' RoomFilter (Maybe RoomEventFilter)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomFilter -> Maybe RoomEventFilter
getter RoomFilter -> Maybe RoomEventFilter -> RoomFilter
setter
  where
    getter :: RoomFilter -> Maybe RoomEventFilter
getter = RoomFilter -> Maybe RoomEventFilter
rfAccountData
    setter :: RoomFilter -> Maybe RoomEventFilter -> RoomFilter
setter RoomFilter
rm Maybe RoomEventFilter
rfad = RoomFilter
rm { rfAccountData :: Maybe RoomEventFilter
rfAccountData = Maybe RoomEventFilter
rfad }

_filterEventFields :: Lens' Filter (Maybe [T.Text])
_filterEventFields :: (Maybe [Text] -> f (Maybe [Text])) -> Filter -> f Filter
_filterEventFields = (Filter -> Maybe [Text])
-> (Filter -> Maybe [Text] -> Filter)
-> Lens' Filter (Maybe [Text])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens Filter -> Maybe [Text]
getter Filter -> Maybe [Text] -> Filter
setter
  where
    getter :: Filter -> Maybe [Text]
getter = Filter -> Maybe [Text]
filterEventFields
    setter :: Filter -> Maybe [Text] -> Filter
setter Filter
fltr Maybe [Text]
fef = Filter
fltr { filterEventFields :: Maybe [Text]
filterEventFields = Maybe [Text]
fef }

_filterEventFormat :: Lens' Filter (Maybe EventFormat)
_filterEventFormat :: (Maybe EventFormat -> f (Maybe EventFormat)) -> Filter -> f Filter
_filterEventFormat = (Filter -> Maybe EventFormat)
-> (Filter -> Maybe EventFormat -> Filter)
-> Lens' Filter (Maybe EventFormat)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens Filter -> Maybe EventFormat
getter Filter -> Maybe EventFormat -> Filter
setter
  where
    getter :: Filter -> Maybe EventFormat
getter = Filter -> Maybe EventFormat
filterEventFormat
    setter :: Filter -> Maybe EventFormat -> Filter
setter Filter
fltr Maybe EventFormat
fef = Filter
fltr { filterEventFormat :: Maybe EventFormat
filterEventFormat = Maybe EventFormat
fef }

_filterPresence :: Lens' Filter (Maybe EventFilter)
_filterPresence :: (Maybe EventFilter -> f (Maybe EventFilter)) -> Filter -> f Filter
_filterPresence = (Filter -> Maybe EventFilter)
-> (Filter -> Maybe EventFilter -> Filter)
-> Lens' Filter (Maybe EventFilter)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens Filter -> Maybe EventFilter
getter Filter -> Maybe EventFilter -> Filter
setter
  where
    getter :: Filter -> Maybe EventFilter
getter = Filter -> Maybe EventFilter
filterPresence
    setter :: Filter -> Maybe EventFilter -> Filter
setter Filter
fltr Maybe EventFilter
fp = Filter
fltr { filterPresence :: Maybe EventFilter
filterPresence = Maybe EventFilter
fp }

_filterAccountData :: Lens' Filter (Maybe EventFilter)
_filterAccountData :: (Maybe EventFilter -> f (Maybe EventFilter)) -> Filter -> f Filter
_filterAccountData = (Filter -> Maybe EventFilter)
-> (Filter -> Maybe EventFilter -> Filter)
-> Lens' Filter (Maybe EventFilter)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens Filter -> Maybe EventFilter
getter Filter -> Maybe EventFilter -> Filter
setter
  where
    getter :: Filter -> Maybe EventFilter
getter = Filter -> Maybe EventFilter
filterAccountData
    setter :: Filter -> Maybe EventFilter -> Filter
setter Filter
fltr Maybe EventFilter
fac = Filter
fltr { filterAccountData :: Maybe EventFilter
filterAccountData = Maybe EventFilter
fac }

_filterRoom :: Lens' Filter (Maybe RoomFilter)
_filterRoom :: (Maybe RoomFilter -> f (Maybe RoomFilter)) -> Filter -> f Filter
_filterRoom = (Filter -> Maybe RoomFilter)
-> (Filter -> Maybe RoomFilter -> Filter)
-> Lens' Filter (Maybe RoomFilter)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens Filter -> Maybe RoomFilter
getter Filter -> Maybe RoomFilter -> Filter
setter
  where
    getter :: Filter -> Maybe RoomFilter
getter = Filter -> Maybe RoomFilter
filterRoom
    setter :: Filter -> Maybe RoomFilter -> Filter
setter Filter
fltr Maybe RoomFilter
fr = Filter
fltr { filterRoom :: Maybe RoomFilter
filterRoom = Maybe RoomFilter
fr }

_reContent :: Lens' RoomEvent Event
_reContent :: (Event -> f Event) -> RoomEvent -> f RoomEvent
_reContent = (RoomEvent -> Event)
-> (RoomEvent -> Event -> RoomEvent) -> Lens' RoomEvent Event
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEvent -> Event
getter RoomEvent -> Event -> RoomEvent
setter
  where
    getter :: RoomEvent -> Event
getter = RoomEvent -> Event
reContent
    setter :: RoomEvent -> Event -> RoomEvent
setter RoomEvent
rEvent Event
rc = RoomEvent
rEvent { reContent :: Event
reContent = Event
rc }

_reType :: Lens' RoomEvent T.Text
_reType :: (Text -> f Text) -> RoomEvent -> f RoomEvent
_reType = (RoomEvent -> Text)
-> (RoomEvent -> Text -> RoomEvent) -> Lens' RoomEvent Text
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEvent -> Text
getter RoomEvent -> Text -> RoomEvent
setter
  where
    getter :: RoomEvent -> Text
getter = RoomEvent -> Text
reType
    setter :: RoomEvent -> Text -> RoomEvent
setter RoomEvent
rEvent Text
rt = RoomEvent
rEvent { reType :: Text
reType = Text
rt }

_reEventId :: Lens' RoomEvent EventID
_reEventId :: (EventID -> f EventID) -> RoomEvent -> f RoomEvent
_reEventId = (RoomEvent -> EventID)
-> (RoomEvent -> EventID -> RoomEvent) -> Lens' RoomEvent EventID
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEvent -> EventID
getter RoomEvent -> EventID -> RoomEvent
setter
  where
    getter :: RoomEvent -> EventID
getter = RoomEvent -> EventID
reEventId
    setter :: RoomEvent -> EventID -> RoomEvent
setter RoomEvent
rEvent EventID
reid = RoomEvent
rEvent { reEventId :: EventID
reEventId = EventID
reid }

_reSender :: Lens' RoomEvent Author
_reSender :: (Author -> f Author) -> RoomEvent -> f RoomEvent
_reSender = (RoomEvent -> Author)
-> (RoomEvent -> Author -> RoomEvent) -> Lens' RoomEvent Author
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomEvent -> Author
getter RoomEvent -> Author -> RoomEvent
setter
  where
    getter :: RoomEvent -> Author
getter = RoomEvent -> Author
reSender
    setter :: RoomEvent -> Author -> RoomEvent
setter RoomEvent
rEvent Author
res = RoomEvent
rEvent { reSender :: Author
reSender = Author
res }

_rsJoinedMemberCount :: Lens' RoomSummary (Maybe Int)
_rsJoinedMemberCount :: (Maybe Int -> f (Maybe Int)) -> RoomSummary -> f RoomSummary
_rsJoinedMemberCount = (RoomSummary -> Maybe Int)
-> (RoomSummary -> Maybe Int -> RoomSummary)
-> Lens' RoomSummary (Maybe Int)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomSummary -> Maybe Int
getter RoomSummary -> Maybe Int -> RoomSummary
setter
  where
    getter :: RoomSummary -> Maybe Int
getter = RoomSummary -> Maybe Int
rsJoinedMemberCount
    setter :: RoomSummary -> Maybe Int -> RoomSummary
setter RoomSummary
rs Maybe Int
rsjmc = RoomSummary
rs { rsJoinedMemberCount :: Maybe Int
rsJoinedMemberCount = Maybe Int
rsjmc }

_rsInvitedMemberCount :: Lens' RoomSummary (Maybe Int)
_rsInvitedMemberCount :: (Maybe Int -> f (Maybe Int)) -> RoomSummary -> f RoomSummary
_rsInvitedMemberCount = (RoomSummary -> Maybe Int)
-> (RoomSummary -> Maybe Int -> RoomSummary)
-> Lens' RoomSummary (Maybe Int)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens RoomSummary -> Maybe Int
getter RoomSummary -> Maybe Int -> RoomSummary
setter
  where
    getter :: RoomSummary -> Maybe Int
getter = RoomSummary -> Maybe Int
rsInvitedMemberCount
    setter :: RoomSummary -> Maybe Int -> RoomSummary
setter RoomSummary
rs Maybe Int
rsimc = RoomSummary
rs { rsInvitedMemberCount :: Maybe Int
rsInvitedMemberCount = Maybe Int
rsimc }

_tsEvents :: Lens' TimelineSync (Maybe [RoomEvent])
_tsEvents :: (Maybe [RoomEvent] -> f (Maybe [RoomEvent]))
-> TimelineSync -> f TimelineSync
_tsEvents = (TimelineSync -> Maybe [RoomEvent])
-> (TimelineSync -> Maybe [RoomEvent] -> TimelineSync)
-> Lens' TimelineSync (Maybe [RoomEvent])
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens TimelineSync -> Maybe [RoomEvent]
getter TimelineSync -> Maybe [RoomEvent] -> TimelineSync
setter
  where
    getter :: TimelineSync -> Maybe [RoomEvent]
getter = TimelineSync -> Maybe [RoomEvent]
tsEvents
    setter :: TimelineSync -> Maybe [RoomEvent] -> TimelineSync
setter TimelineSync
ts Maybe [RoomEvent]
tse = TimelineSync
ts { tsEvents :: Maybe [RoomEvent]
tsEvents = Maybe [RoomEvent]
tse }

_tsLimited :: Lens' TimelineSync (Maybe Bool)
_tsLimited :: (Maybe Bool -> f (Maybe Bool)) -> TimelineSync -> f TimelineSync
_tsLimited = (TimelineSync -> Maybe Bool)
-> (TimelineSync -> Maybe Bool -> TimelineSync)
-> Lens' TimelineSync (Maybe Bool)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens TimelineSync -> Maybe Bool
getter TimelineSync -> Maybe Bool -> TimelineSync
setter
  where
    getter :: TimelineSync -> Maybe Bool
getter = TimelineSync -> Maybe Bool
tsLimited
    setter :: TimelineSync -> Maybe Bool -> TimelineSync
setter TimelineSync
ts Maybe Bool
tsl = TimelineSync
ts { tsLimited :: Maybe Bool
tsLimited = Maybe Bool
tsl }

_tsPrevBatch :: Lens' TimelineSync (Maybe T.Text)
_tsPrevBatch :: (Maybe Text -> f (Maybe Text)) -> TimelineSync -> f TimelineSync
_tsPrevBatch = (TimelineSync -> Maybe Text)
-> (TimelineSync -> Maybe Text -> TimelineSync)
-> Lens' TimelineSync (Maybe Text)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens TimelineSync -> Maybe Text
getter TimelineSync -> Maybe Text -> TimelineSync
setter
  where
    getter :: TimelineSync -> Maybe Text
getter = TimelineSync -> Maybe Text
tsPrevBatch
    setter :: TimelineSync -> Maybe Text -> TimelineSync
setter TimelineSync
ts Maybe Text
tspb = TimelineSync
ts { tsPrevBatch :: Maybe Text
tsPrevBatch = Maybe Text
tspb }

_jrsSummary :: Lens' JoinedRoomSync (Maybe RoomSummary)
_jrsSummary :: (Maybe RoomSummary -> f (Maybe RoomSummary))
-> JoinedRoomSync -> f JoinedRoomSync
_jrsSummary = (JoinedRoomSync -> Maybe RoomSummary)
-> (JoinedRoomSync -> Maybe RoomSummary -> JoinedRoomSync)
-> Lens' JoinedRoomSync (Maybe RoomSummary)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens JoinedRoomSync -> Maybe RoomSummary
getter JoinedRoomSync -> Maybe RoomSummary -> JoinedRoomSync
setter
  where
    getter :: JoinedRoomSync -> Maybe RoomSummary
getter = JoinedRoomSync -> Maybe RoomSummary
jrsSummary
    setter :: JoinedRoomSync -> Maybe RoomSummary -> JoinedRoomSync
setter JoinedRoomSync
jrs Maybe RoomSummary
jrss = JoinedRoomSync
jrs { jrsSummary :: Maybe RoomSummary
jrsSummary = Maybe RoomSummary
jrss }

_jrsTimeline :: Lens' JoinedRoomSync TimelineSync
_jrsTimeline :: (TimelineSync -> f TimelineSync)
-> JoinedRoomSync -> f JoinedRoomSync
_jrsTimeline = (JoinedRoomSync -> TimelineSync)
-> (JoinedRoomSync -> TimelineSync -> JoinedRoomSync)
-> Lens' JoinedRoomSync TimelineSync
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens JoinedRoomSync -> TimelineSync
getter JoinedRoomSync -> TimelineSync -> JoinedRoomSync
setter
  where
    getter :: JoinedRoomSync -> TimelineSync
getter = JoinedRoomSync -> TimelineSync
jrsTimeline
    setter :: JoinedRoomSync -> TimelineSync -> JoinedRoomSync
setter JoinedRoomSync
jrs TimelineSync
jrst = JoinedRoomSync
jrs { jrsTimeline :: TimelineSync
jrsTimeline = TimelineSync
jrst }

_srNextBatch :: Lens' SyncResult T.Text
_srNextBatch :: (Text -> f Text) -> SyncResult -> f SyncResult
_srNextBatch = (SyncResult -> Text)
-> (SyncResult -> Text -> SyncResult) -> Lens' SyncResult Text
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens SyncResult -> Text
getter SyncResult -> Text -> SyncResult
setter
  where
    getter :: SyncResult -> Text
getter = SyncResult -> Text
srNextBatch
    setter :: SyncResult -> Text -> SyncResult
setter SyncResult
sr Text
srnb = SyncResult
sr { srNextBatch :: Text
srNextBatch = Text
srnb }

_srRooms :: Lens' SyncResult (Maybe SyncResultRoom)
_srRooms :: (Maybe SyncResultRoom -> f (Maybe SyncResultRoom))
-> SyncResult -> f SyncResult
_srRooms = (SyncResult -> Maybe SyncResultRoom)
-> (SyncResult -> Maybe SyncResultRoom -> SyncResult)
-> Lens' SyncResult (Maybe SyncResultRoom)
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens SyncResult -> Maybe SyncResultRoom
getter SyncResult -> Maybe SyncResultRoom -> SyncResult
setter
  where
    getter :: SyncResult -> Maybe SyncResultRoom
getter = SyncResult -> Maybe SyncResultRoom
srRooms
    setter :: SyncResult -> Maybe SyncResultRoom -> SyncResult
setter SyncResult
sr Maybe SyncResultRoom
srr = SyncResult
sr { srRooms :: Maybe SyncResultRoom
srRooms = Maybe SyncResultRoom
srr }

_srrJoin :: Lens' SyncResultRoom (Maybe (M.Map T.Text JoinedRoomSync))
_srrJoin :: (Maybe (Map Text JoinedRoomSync)
 -> f (Maybe (Map Text JoinedRoomSync)))
-> SyncResultRoom -> f SyncResultRoom
_srrJoin = (SyncResultRoom -> Maybe (Map Text JoinedRoomSync))
-> (SyncResultRoom
    -> Maybe (Map Text JoinedRoomSync) -> SyncResultRoom)
-> Lens' SyncResultRoom (Maybe (Map Text JoinedRoomSync))
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens SyncResultRoom -> Maybe (Map Text JoinedRoomSync)
getter SyncResultRoom -> Maybe (Map Text JoinedRoomSync) -> SyncResultRoom
setter
  where
    getter :: SyncResultRoom -> Maybe (Map Text JoinedRoomSync)
getter = SyncResultRoom -> Maybe (Map Text JoinedRoomSync)
srrJoin
    setter :: SyncResultRoom -> Maybe (Map Text JoinedRoomSync) -> SyncResultRoom
setter SyncResultRoom
srr Maybe (Map Text JoinedRoomSync)
srrj = SyncResultRoom
srr { srrJoin :: Maybe (Map Text JoinedRoomSync)
srrJoin = Maybe (Map Text JoinedRoomSync)
srrj }

_srrInvite :: Lens' SyncResultRoom (Maybe (M.Map T.Text InvitedRoomSync))
_srrInvite :: (Maybe (Map Text InvitedRoomSync)
 -> f (Maybe (Map Text InvitedRoomSync)))
-> SyncResultRoom -> f SyncResultRoom
_srrInvite = (SyncResultRoom -> Maybe (Map Text InvitedRoomSync))
-> (SyncResultRoom
    -> Maybe (Map Text InvitedRoomSync) -> SyncResultRoom)
-> Lens' SyncResultRoom (Maybe (Map Text InvitedRoomSync))
forall s a. (s -> a) -> (s -> a -> s) -> Lens' s a
lens SyncResultRoom -> Maybe (Map Text InvitedRoomSync)
getter SyncResultRoom
-> Maybe (Map Text InvitedRoomSync) -> SyncResultRoom
setter
  where
    getter :: SyncResultRoom -> Maybe (Map Text InvitedRoomSync)
getter = SyncResultRoom -> Maybe (Map Text InvitedRoomSync)
srrInvite
    setter :: SyncResultRoom
-> Maybe (Map Text InvitedRoomSync) -> SyncResultRoom
setter SyncResultRoom
srr Maybe (Map Text InvitedRoomSync)
srri = SyncResultRoom
srr { srrInvite :: Maybe (Map Text InvitedRoomSync)
srrInvite = Maybe (Map Text InvitedRoomSync)
srri }