1456 lines
30 KiB
Elm
1456 lines
30 KiB
Elm
module Internal.Tools.SpecEnums exposing (..)
|
|
|
|
import Json.Decode as D
|
|
import Json.Encode as E
|
|
|
|
|
|
{-| The kind of account - currently defined as regular users and guests.
|
|
-}
|
|
type AccountKind
|
|
= Guest
|
|
| User
|
|
|
|
|
|
{-| Encode the AccountKindtype into a JSON Value
|
|
-}
|
|
encodeAccountKind : AccountKind -> E.Value
|
|
encodeAccountKind =
|
|
encodeEnum fromAccountKind
|
|
|
|
|
|
{-| Convert the AccountKind type into a string.
|
|
-}
|
|
fromAccountKind : AccountKind -> String
|
|
fromAccountKind enum =
|
|
case enum of
|
|
Guest ->
|
|
"guest"
|
|
|
|
User ->
|
|
"user"
|
|
|
|
|
|
{-| Decodes the AccountKind type from a JSON String
|
|
-}
|
|
accountKindDecoder : D.Decoder AccountKind
|
|
accountKindDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"guest" ->
|
|
D.succeed Guest
|
|
|
|
"user" ->
|
|
D.succeed User
|
|
|
|
_ ->
|
|
D.fail "Expected one of [guest, user]"
|
|
)
|
|
|
|
|
|
{-| Algorithm used for storing backups.
|
|
-}
|
|
type BackupStorageAlgorithm
|
|
= MegolmBackupV1Curve25519aesSHA2
|
|
|
|
|
|
{-| Encode the BackupStorageAlgorithmtype into a JSON Value
|
|
-}
|
|
encodeBackupStorageAlgorithm : BackupStorageAlgorithm -> E.Value
|
|
encodeBackupStorageAlgorithm =
|
|
encodeEnum fromBackupStorageAlgorithm
|
|
|
|
|
|
{-| Convert the BackupStorageAlgorithm type into a string.
|
|
-}
|
|
fromBackupStorageAlgorithm : BackupStorageAlgorithm -> String
|
|
fromBackupStorageAlgorithm enum =
|
|
case enum of
|
|
MegolmBackupV1Curve25519aesSHA2 ->
|
|
"m.megolm_backup.v1.curve25519-aes-sha2"
|
|
|
|
|
|
{-| Decodes the BackupStorageAlgorithm type from a JSON String
|
|
-}
|
|
backupStorageAlgorithmDecoder : D.Decoder BackupStorageAlgorithm
|
|
backupStorageAlgorithmDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"m.megolm_backup.v1.curve25519-aes-sha2" ->
|
|
D.succeed MegolmBackupV1Curve25519aesSHA2
|
|
|
|
_ ->
|
|
D.fail "Expected one of [m.megolm_backup.v1.curve25519-aes-sha2]"
|
|
)
|
|
|
|
|
|
{-| A type of condition that must be satisfied.
|
|
-}
|
|
type ConditionType
|
|
= RoomMembershipCondition
|
|
|
|
|
|
{-| Encode the ConditionTypetype into a JSON Value
|
|
-}
|
|
encodeConditionType : ConditionType -> E.Value
|
|
encodeConditionType =
|
|
encodeEnum fromConditionType
|
|
|
|
|
|
{-| Convert the ConditionType type into a string.
|
|
-}
|
|
fromConditionType : ConditionType -> String
|
|
fromConditionType enum =
|
|
case enum of
|
|
RoomMembershipCondition ->
|
|
"m.room.membership"
|
|
|
|
|
|
{-| Decodes the ConditionType type from a JSON String
|
|
-}
|
|
conditionTypeDecoder : D.Decoder ConditionType
|
|
conditionTypeDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"m.room.membership" ->
|
|
D.succeed RoomMembershipCondition
|
|
|
|
_ ->
|
|
D.fail "Expected one of [m.room.membership]"
|
|
)
|
|
|
|
|
|
{-| The encryption algorithm an event is encrypted with.
|
|
-}
|
|
type EncryptionAlgorithm
|
|
= OlmV1Curve25519aesSHA2
|
|
| MegolmV1aesSHA2
|
|
|
|
|
|
{-| Encode the EncryptionAlgorithmtype into a JSON Value
|
|
-}
|
|
encodeEncryptionAlgorithm : EncryptionAlgorithm -> E.Value
|
|
encodeEncryptionAlgorithm =
|
|
encodeEnum fromEncryptionAlgorithm
|
|
|
|
|
|
{-| Convert the EncryptionAlgorithm type into a string.
|
|
-}
|
|
fromEncryptionAlgorithm : EncryptionAlgorithm -> String
|
|
fromEncryptionAlgorithm enum =
|
|
case enum of
|
|
OlmV1Curve25519aesSHA2 ->
|
|
"m.olm.v1.curve25519-aes-sha2"
|
|
|
|
MegolmV1aesSHA2 ->
|
|
"m.megolm.v1.aes-sha2"
|
|
|
|
|
|
{-| Decodes the EncryptionAlgorithm type from a JSON String
|
|
-}
|
|
encryptionAlgorithmDecoder : D.Decoder EncryptionAlgorithm
|
|
encryptionAlgorithmDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"m.olm.v1.curve25519-aes-sha2" ->
|
|
D.succeed OlmV1Curve25519aesSHA2
|
|
|
|
"m.megolm.v1.aes-sha2" ->
|
|
D.succeed MegolmV1aesSHA2
|
|
|
|
_ ->
|
|
D.fail "Expected one of [m.olm.v1.curve25519-aes-sha2, m.megolm.v1.aes-sha2]"
|
|
)
|
|
|
|
|
|
{-| Whether an event should be formatted for a client or for federation purposes.
|
|
-}
|
|
type EventFormat
|
|
= Client
|
|
| Federation
|
|
|
|
|
|
{-| Encode the EventFormattype into a JSON Value
|
|
-}
|
|
encodeEventFormat : EventFormat -> E.Value
|
|
encodeEventFormat =
|
|
encodeEnum fromEventFormat
|
|
|
|
|
|
{-| Convert the EventFormat type into a string.
|
|
-}
|
|
fromEventFormat : EventFormat -> String
|
|
fromEventFormat enum =
|
|
case enum of
|
|
Client ->
|
|
"client"
|
|
|
|
Federation ->
|
|
"federation"
|
|
|
|
|
|
{-| Decodes the EventFormat type from a JSON String
|
|
-}
|
|
eventFormatDecoder : D.Decoder EventFormat
|
|
eventFormatDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"client" ->
|
|
D.succeed Client
|
|
|
|
"federation" ->
|
|
D.succeed Federation
|
|
|
|
_ ->
|
|
D.fail "Expected one of [client, federation]"
|
|
)
|
|
|
|
|
|
{-| How events are expected to be ordered.
|
|
-}
|
|
type EventOrder
|
|
= Chronological
|
|
| ReverseChronological
|
|
|
|
|
|
{-| Encode the EventOrdertype into a JSON Value
|
|
-}
|
|
encodeEventOrder : EventOrder -> E.Value
|
|
encodeEventOrder =
|
|
encodeEnum fromEventOrder
|
|
|
|
|
|
{-| Convert the EventOrder type into a string.
|
|
-}
|
|
fromEventOrder : EventOrder -> String
|
|
fromEventOrder enum =
|
|
case enum of
|
|
Chronological ->
|
|
"f"
|
|
|
|
ReverseChronological ->
|
|
"b"
|
|
|
|
|
|
{-| Decodes the EventOrder type from a JSON String
|
|
-}
|
|
eventOrderDecoder : D.Decoder EventOrder
|
|
eventOrderDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"f" ->
|
|
D.succeed Chronological
|
|
|
|
"b" ->
|
|
D.succeed ReverseChronological
|
|
|
|
_ ->
|
|
D.fail "Expected one of [f, b]"
|
|
)
|
|
|
|
|
|
{-| Key that defines a search request group.
|
|
-}
|
|
type GroupKey
|
|
= RoomIDKey
|
|
| SenderKey
|
|
|
|
|
|
{-| Encode the GroupKeytype into a JSON Value
|
|
-}
|
|
encodeGroupKey : GroupKey -> E.Value
|
|
encodeGroupKey =
|
|
encodeEnum fromGroupKey
|
|
|
|
|
|
{-| Convert the GroupKey type into a string.
|
|
-}
|
|
fromGroupKey : GroupKey -> String
|
|
fromGroupKey enum =
|
|
case enum of
|
|
RoomIDKey ->
|
|
"room_id"
|
|
|
|
SenderKey ->
|
|
"sender"
|
|
|
|
|
|
{-| Decodes the GroupKey type from a JSON String
|
|
-}
|
|
groupKeyDecoder : D.Decoder GroupKey
|
|
groupKeyDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"room_id" ->
|
|
D.succeed RoomIDKey
|
|
|
|
"sender" ->
|
|
D.succeed SenderKey
|
|
|
|
_ ->
|
|
D.fail "Expected one of [room_id, sender]"
|
|
)
|
|
|
|
|
|
{-| Whether guests are allowed to join.
|
|
-}
|
|
type GuestAccess
|
|
= GuestsAreWelcome
|
|
| GuestsAreForbidden
|
|
|
|
|
|
{-| Encode the GuestAccesstype into a JSON Value
|
|
-}
|
|
encodeGuestAccess : GuestAccess -> E.Value
|
|
encodeGuestAccess =
|
|
encodeEnum fromGuestAccess
|
|
|
|
|
|
{-| Convert the GuestAccess type into a string.
|
|
-}
|
|
fromGuestAccess : GuestAccess -> String
|
|
fromGuestAccess enum =
|
|
case enum of
|
|
GuestsAreWelcome ->
|
|
"can_join"
|
|
|
|
GuestsAreForbidden ->
|
|
"forbidden"
|
|
|
|
|
|
{-| Decodes the GuestAccess type from a JSON String
|
|
-}
|
|
guestAccessDecoder : D.Decoder GuestAccess
|
|
guestAccessDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"can_join" ->
|
|
D.succeed GuestsAreWelcome
|
|
|
|
"forbidden" ->
|
|
D.succeed GuestsAreForbidden
|
|
|
|
_ ->
|
|
D.fail "Expected one of [can_join, forbidden]"
|
|
)
|
|
|
|
|
|
{-| Error reason for a call hangup.
|
|
-}
|
|
type HangupReason
|
|
= IceFailed
|
|
| InviteTimeout
|
|
|
|
|
|
{-| Encode the HangupReasontype into a JSON Value
|
|
-}
|
|
encodeHangupReason : HangupReason -> E.Value
|
|
encodeHangupReason =
|
|
encodeEnum fromHangupReason
|
|
|
|
|
|
{-| Convert the HangupReason type into a string.
|
|
-}
|
|
fromHangupReason : HangupReason -> String
|
|
fromHangupReason enum =
|
|
case enum of
|
|
IceFailed ->
|
|
"ice_failed"
|
|
|
|
InviteTimeout ->
|
|
"invite_timeout"
|
|
|
|
|
|
{-| Decodes the HangupReason type from a JSON String
|
|
-}
|
|
hangupReasonDecoder : D.Decoder HangupReason
|
|
hangupReasonDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"ice_failed" ->
|
|
D.succeed IceFailed
|
|
|
|
"invite_timeout" ->
|
|
D.succeed InviteTimeout
|
|
|
|
_ ->
|
|
D.fail "Expected one of [ice_failed, invite_timeout]"
|
|
)
|
|
|
|
|
|
{-| The history visibility of a room.
|
|
-}
|
|
type HistoryVisibility
|
|
= FromMomentOfInvite
|
|
| FromMomentOfJoined
|
|
| FullHistoryToMembers
|
|
| FullHistoryToLiterallyEveryone
|
|
|
|
|
|
{-| Encode the HistoryVisibilitytype into a JSON Value
|
|
-}
|
|
encodeHistoryVisibility : HistoryVisibility -> E.Value
|
|
encodeHistoryVisibility =
|
|
encodeEnum fromHistoryVisibility
|
|
|
|
|
|
{-| Convert the HistoryVisibility type into a string.
|
|
-}
|
|
fromHistoryVisibility : HistoryVisibility -> String
|
|
fromHistoryVisibility enum =
|
|
case enum of
|
|
FromMomentOfInvite ->
|
|
"invited"
|
|
|
|
FromMomentOfJoined ->
|
|
"joined"
|
|
|
|
FullHistoryToMembers ->
|
|
"shared"
|
|
|
|
FullHistoryToLiterallyEveryone ->
|
|
"world_readable"
|
|
|
|
|
|
{-| Decodes the HistoryVisibility type from a JSON String
|
|
-}
|
|
historyVisibilityDecoder : D.Decoder HistoryVisibility
|
|
historyVisibilityDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"invited" ->
|
|
D.succeed FromMomentOfInvite
|
|
|
|
"joined" ->
|
|
D.succeed FromMomentOfJoined
|
|
|
|
"shared" ->
|
|
D.succeed FullHistoryToMembers
|
|
|
|
"world_readable" ->
|
|
D.succeed FullHistoryToLiterallyEveryone
|
|
|
|
_ ->
|
|
D.fail "Expected one of [invited, joined, shared, world_readable]"
|
|
)
|
|
|
|
|
|
{-| Flag to denote which thread roots are to be included.
|
|
-}
|
|
type IncludeThreads
|
|
= IncludeAllThreads
|
|
| IncludeParticipatedThreads
|
|
|
|
|
|
{-| Encode the IncludeThreadstype into a JSON Value
|
|
-}
|
|
encodeIncludeThreads : IncludeThreads -> E.Value
|
|
encodeIncludeThreads =
|
|
encodeEnum fromIncludeThreads
|
|
|
|
|
|
{-| Convert the IncludeThreads type into a string.
|
|
-}
|
|
fromIncludeThreads : IncludeThreads -> String
|
|
fromIncludeThreads enum =
|
|
case enum of
|
|
IncludeAllThreads ->
|
|
"all"
|
|
|
|
IncludeParticipatedThreads ->
|
|
"participated"
|
|
|
|
|
|
{-| Decodes the IncludeThreads type from a JSON String
|
|
-}
|
|
includeThreadsDecoder : D.Decoder IncludeThreads
|
|
includeThreadsDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"all" ->
|
|
D.succeed IncludeAllThreads
|
|
|
|
"participated" ->
|
|
D.succeed IncludeParticipatedThreads
|
|
|
|
_ ->
|
|
D.fail "Expected one of [all, participated]"
|
|
)
|
|
|
|
|
|
{-| The type of rules used for users wishing to join a room.
|
|
-}
|
|
type JoinRules
|
|
= Public
|
|
| Knock
|
|
| Invite
|
|
| Private
|
|
| Restricted
|
|
|
|
|
|
{-| Encode the JoinRulestype into a JSON Value
|
|
-}
|
|
encodeJoinRules : JoinRules -> E.Value
|
|
encodeJoinRules =
|
|
encodeEnum fromJoinRules
|
|
|
|
|
|
{-| Convert the JoinRules type into a string.
|
|
-}
|
|
fromJoinRules : JoinRules -> String
|
|
fromJoinRules enum =
|
|
case enum of
|
|
Public ->
|
|
"public"
|
|
|
|
Knock ->
|
|
"knock"
|
|
|
|
Invite ->
|
|
"invite"
|
|
|
|
Private ->
|
|
"private"
|
|
|
|
Restricted ->
|
|
"restricted"
|
|
|
|
|
|
{-| Decodes the JoinRules type from a JSON String
|
|
-}
|
|
joinRulesDecoder : D.Decoder JoinRules
|
|
joinRulesDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"public" ->
|
|
D.succeed Public
|
|
|
|
"knock" ->
|
|
D.succeed Knock
|
|
|
|
"invite" ->
|
|
D.succeed Invite
|
|
|
|
"private" ->
|
|
D.succeed Private
|
|
|
|
"restricted" ->
|
|
D.succeed Restricted
|
|
|
|
_ ->
|
|
D.fail "Expected one of [public, knock, invite, private, restricted]"
|
|
)
|
|
|
|
|
|
{-| Given type that a user may log in with.
|
|
-}
|
|
type LoginType
|
|
= Password
|
|
| SSO
|
|
| Token
|
|
|
|
|
|
{-| Encode the LoginTypetype into a JSON Value
|
|
-}
|
|
encodeLoginType : LoginType -> E.Value
|
|
encodeLoginType =
|
|
encodeEnum fromLoginType
|
|
|
|
|
|
{-| Convert the LoginType type into a string.
|
|
-}
|
|
fromLoginType : LoginType -> String
|
|
fromLoginType enum =
|
|
case enum of
|
|
Password ->
|
|
"m.login.password"
|
|
|
|
SSO ->
|
|
"m.login.sso"
|
|
|
|
Token ->
|
|
"m.login.token"
|
|
|
|
|
|
{-| Decodes the LoginType type from a JSON String
|
|
-}
|
|
loginTypeDecoder : D.Decoder LoginType
|
|
loginTypeDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"m.login.password" ->
|
|
D.succeed Password
|
|
|
|
"m.login.sso" ->
|
|
D.succeed SSO
|
|
|
|
"m.login.token" ->
|
|
D.succeed Token
|
|
|
|
_ ->
|
|
D.fail "Expected one of [m.login.password, m.login.sso, m.login.token]"
|
|
)
|
|
|
|
|
|
{-| The membership state of a user in a room.
|
|
-}
|
|
type MembershipState
|
|
= Invited
|
|
| Joined
|
|
| Knocked
|
|
| Left
|
|
| Banned
|
|
|
|
|
|
{-| Encode the MembershipStatetype into a JSON Value
|
|
-}
|
|
encodeMembershipState : MembershipState -> E.Value
|
|
encodeMembershipState =
|
|
encodeEnum fromMembershipState
|
|
|
|
|
|
{-| Convert the MembershipState type into a string.
|
|
-}
|
|
fromMembershipState : MembershipState -> String
|
|
fromMembershipState enum =
|
|
case enum of
|
|
Invited ->
|
|
"invite"
|
|
|
|
Joined ->
|
|
"join"
|
|
|
|
Knocked ->
|
|
"knock"
|
|
|
|
Left ->
|
|
"leave"
|
|
|
|
Banned ->
|
|
"ban"
|
|
|
|
|
|
{-| Decodes the MembershipState type from a JSON String
|
|
-}
|
|
membershipStateDecoder : D.Decoder MembershipState
|
|
membershipStateDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"invite" ->
|
|
D.succeed Invited
|
|
|
|
"join" ->
|
|
D.succeed Joined
|
|
|
|
"knock" ->
|
|
D.succeed Knocked
|
|
|
|
"leave" ->
|
|
D.succeed Left
|
|
|
|
"ban" ->
|
|
D.succeed Banned
|
|
|
|
_ ->
|
|
D.fail "Expected one of [invite, join, knock, leave, ban]"
|
|
)
|
|
|
|
|
|
{-| The type of message sent in an `m.room.message` event.
|
|
-}
|
|
type MessageType
|
|
= Text
|
|
| Emote
|
|
| Notice
|
|
| Image
|
|
| File
|
|
| Audio
|
|
| Location
|
|
| Video
|
|
| VerificationRequest
|
|
| ServerNotice
|
|
|
|
|
|
{-| Encode the MessageTypetype into a JSON Value
|
|
-}
|
|
encodeMessageType : MessageType -> E.Value
|
|
encodeMessageType =
|
|
encodeEnum fromMessageType
|
|
|
|
|
|
{-| Convert the MessageType type into a string.
|
|
-}
|
|
fromMessageType : MessageType -> String
|
|
fromMessageType enum =
|
|
case enum of
|
|
Text ->
|
|
"m.text"
|
|
|
|
Emote ->
|
|
"m.emote"
|
|
|
|
Notice ->
|
|
"m.notice"
|
|
|
|
Image ->
|
|
"m.image"
|
|
|
|
File ->
|
|
"m.file"
|
|
|
|
Audio ->
|
|
"m.audio"
|
|
|
|
Location ->
|
|
"m.location"
|
|
|
|
Video ->
|
|
"m.video"
|
|
|
|
VerificationRequest ->
|
|
"m.key.verification.request"
|
|
|
|
ServerNotice ->
|
|
"m.server_notice"
|
|
|
|
|
|
{-| Decodes the MessageType type from a JSON String
|
|
-}
|
|
messageTypeDecoder : D.Decoder MessageType
|
|
messageTypeDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"m.text" ->
|
|
D.succeed Text
|
|
|
|
"m.emote" ->
|
|
D.succeed Emote
|
|
|
|
"m.notice" ->
|
|
D.succeed Notice
|
|
|
|
"m.image" ->
|
|
D.succeed Image
|
|
|
|
"m.file" ->
|
|
D.succeed File
|
|
|
|
"m.audio" ->
|
|
D.succeed Audio
|
|
|
|
"m.location" ->
|
|
D.succeed Location
|
|
|
|
"m.video" ->
|
|
D.succeed Video
|
|
|
|
"m.key.verification.request" ->
|
|
D.succeed VerificationRequest
|
|
|
|
"m.server_notice" ->
|
|
D.succeed ServerNotice
|
|
|
|
_ ->
|
|
D.fail "Expected one of [m.text, m.emote, m.notice, m.image, m.file, m.audio, m.location, m.video, m.key.verification.request, m.server_notice]"
|
|
)
|
|
|
|
|
|
{-| The kind of push rule.
|
|
-}
|
|
type PushRuleKind
|
|
= Override
|
|
| Underride
|
|
| Sender
|
|
| Room
|
|
| Content
|
|
|
|
|
|
{-| Encode the PushRuleKindtype into a JSON Value
|
|
-}
|
|
encodePushRuleKind : PushRuleKind -> E.Value
|
|
encodePushRuleKind =
|
|
encodeEnum fromPushRuleKind
|
|
|
|
|
|
{-| Convert the PushRuleKind type into a string.
|
|
-}
|
|
fromPushRuleKind : PushRuleKind -> String
|
|
fromPushRuleKind enum =
|
|
case enum of
|
|
Override ->
|
|
"override"
|
|
|
|
Underride ->
|
|
"underride"
|
|
|
|
Sender ->
|
|
"sender"
|
|
|
|
Room ->
|
|
"room"
|
|
|
|
Content ->
|
|
"content"
|
|
|
|
|
|
{-| Decodes the PushRuleKind type from a JSON String
|
|
-}
|
|
pushRuleKindDecoder : D.Decoder PushRuleKind
|
|
pushRuleKindDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"override" ->
|
|
D.succeed Override
|
|
|
|
"underride" ->
|
|
D.succeed Underride
|
|
|
|
"sender" ->
|
|
D.succeed Sender
|
|
|
|
"room" ->
|
|
D.succeed Room
|
|
|
|
"content" ->
|
|
D.succeed Content
|
|
|
|
_ ->
|
|
D.fail "Expected one of [override, underride, sender, room, content]"
|
|
)
|
|
|
|
|
|
{-| The type of receipt indicating that a user has read one or more events in a room.
|
|
-}
|
|
type ReceiptType
|
|
= Read
|
|
| ReadPrivate
|
|
| FullyRead
|
|
|
|
|
|
{-| Encode the ReceiptTypetype into a JSON Value
|
|
-}
|
|
encodeReceiptType : ReceiptType -> E.Value
|
|
encodeReceiptType =
|
|
encodeEnum fromReceiptType
|
|
|
|
|
|
{-| Convert the ReceiptType type into a string.
|
|
-}
|
|
fromReceiptType : ReceiptType -> String
|
|
fromReceiptType enum =
|
|
case enum of
|
|
Read ->
|
|
"m.read"
|
|
|
|
ReadPrivate ->
|
|
"m.read.private"
|
|
|
|
FullyRead ->
|
|
"m.fully_read"
|
|
|
|
|
|
{-| Decodes the ReceiptType type from a JSON String
|
|
-}
|
|
receiptTypeDecoder : D.Decoder ReceiptType
|
|
receiptTypeDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"m.read" ->
|
|
D.succeed Read
|
|
|
|
"m.read.private" ->
|
|
D.succeed ReadPrivate
|
|
|
|
"m.fully_read" ->
|
|
D.succeed FullyRead
|
|
|
|
_ ->
|
|
D.fail "Expected one of [m.read, m.read.private, m.fully_read]"
|
|
)
|
|
|
|
|
|
{-| Specified action whenever a key or a secret is requested.
|
|
-}
|
|
type RequestAction
|
|
= Request
|
|
| RequestCancellation
|
|
|
|
|
|
{-| Encode the RequestActiontype into a JSON Value
|
|
-}
|
|
encodeRequestAction : RequestAction -> E.Value
|
|
encodeRequestAction =
|
|
encodeEnum fromRequestAction
|
|
|
|
|
|
{-| Convert the RequestAction type into a string.
|
|
-}
|
|
fromRequestAction : RequestAction -> String
|
|
fromRequestAction enum =
|
|
case enum of
|
|
Request ->
|
|
"request"
|
|
|
|
RequestCancellation ->
|
|
"request_cancellation"
|
|
|
|
|
|
{-| Decodes the RequestAction type from a JSON String
|
|
-}
|
|
requestActionDecoder : D.Decoder RequestAction
|
|
requestActionDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"request" ->
|
|
D.succeed Request
|
|
|
|
"request_cancellation" ->
|
|
D.succeed RequestCancellation
|
|
|
|
_ ->
|
|
D.fail "Expected one of [request, request_cancellation]"
|
|
)
|
|
|
|
|
|
{-| Desired resizing method for images that do not fit.
|
|
-}
|
|
type ResizingMethod
|
|
= Crop
|
|
| Scale
|
|
|
|
|
|
{-| Encode the ResizingMethodtype into a JSON Value
|
|
-}
|
|
encodeResizingMethod : ResizingMethod -> E.Value
|
|
encodeResizingMethod =
|
|
encodeEnum fromResizingMethod
|
|
|
|
|
|
{-| Convert the ResizingMethod type into a string.
|
|
-}
|
|
fromResizingMethod : ResizingMethod -> String
|
|
fromResizingMethod enum =
|
|
case enum of
|
|
Crop ->
|
|
"crop"
|
|
|
|
Scale ->
|
|
"scale"
|
|
|
|
|
|
{-| Decodes the ResizingMethod type from a JSON String
|
|
-}
|
|
resizingMethodDecoder : D.Decoder ResizingMethod
|
|
resizingMethodDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"crop" ->
|
|
D.succeed Crop
|
|
|
|
"scale" ->
|
|
D.succeed Scale
|
|
|
|
_ ->
|
|
D.fail "Expected one of [crop, scale]"
|
|
)
|
|
|
|
|
|
{-| The type of condition that applies to a restricted room.
|
|
-}
|
|
type RestrictedCondition
|
|
= ConditionRoomMembership
|
|
|
|
|
|
{-| Encode the RestrictedConditiontype into a JSON Value
|
|
-}
|
|
encodeRestrictedCondition : RestrictedCondition -> E.Value
|
|
encodeRestrictedCondition =
|
|
encodeEnum fromRestrictedCondition
|
|
|
|
|
|
{-| Convert the RestrictedCondition type into a string.
|
|
-}
|
|
fromRestrictedCondition : RestrictedCondition -> String
|
|
fromRestrictedCondition enum =
|
|
case enum of
|
|
ConditionRoomMembership ->
|
|
"m.room_membership"
|
|
|
|
|
|
{-| Decodes the RestrictedCondition type from a JSON String
|
|
-}
|
|
restrictedConditionDecoder : D.Decoder RestrictedCondition
|
|
restrictedConditionDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"m.room_membership" ->
|
|
D.succeed ConditionRoomMembership
|
|
|
|
_ ->
|
|
D.fail "Expected one of [m.room_membership]"
|
|
)
|
|
|
|
|
|
{-| Room presets that can be called upon room creation.
|
|
-}
|
|
type RoomPreset
|
|
= PrivateChat
|
|
| PublicChat
|
|
| TrustedPrivateChat
|
|
|
|
|
|
{-| Encode the RoomPresettype into a JSON Value
|
|
-}
|
|
encodeRoomPreset : RoomPreset -> E.Value
|
|
encodeRoomPreset =
|
|
encodeEnum fromRoomPreset
|
|
|
|
|
|
{-| Convert the RoomPreset type into a string.
|
|
-}
|
|
fromRoomPreset : RoomPreset -> String
|
|
fromRoomPreset enum =
|
|
case enum of
|
|
PrivateChat ->
|
|
"private_chat"
|
|
|
|
PublicChat ->
|
|
"public_chat"
|
|
|
|
TrustedPrivateChat ->
|
|
"trusted_private_chat"
|
|
|
|
|
|
{-| Decodes the RoomPreset type from a JSON String
|
|
-}
|
|
roomPresetDecoder : D.Decoder RoomPreset
|
|
roomPresetDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"private_chat" ->
|
|
D.succeed PrivateChat
|
|
|
|
"public_chat" ->
|
|
D.succeed PublicChat
|
|
|
|
"trusted_private_chat" ->
|
|
D.succeed TrustedPrivateChat
|
|
|
|
_ ->
|
|
D.fail "Expected one of [private_chat, public_chat, trusted_private_chat]"
|
|
)
|
|
|
|
|
|
{-| The stability of a given room version.
|
|
-}
|
|
type RoomVersionStability
|
|
= Stable
|
|
| Unstable
|
|
|
|
|
|
{-| Encode the RoomVersionStabilitytype into a JSON Value
|
|
-}
|
|
encodeRoomVersionStability : RoomVersionStability -> E.Value
|
|
encodeRoomVersionStability =
|
|
encodeEnum fromRoomVersionStability
|
|
|
|
|
|
{-| Convert the RoomVersionStability type into a string.
|
|
-}
|
|
fromRoomVersionStability : RoomVersionStability -> String
|
|
fromRoomVersionStability enum =
|
|
case enum of
|
|
Stable ->
|
|
"stable"
|
|
|
|
Unstable ->
|
|
"unstable"
|
|
|
|
|
|
{-| Decodes the RoomVersionStability type from a JSON String
|
|
-}
|
|
roomVersionStabilityDecoder : D.Decoder RoomVersionStability
|
|
roomVersionStabilityDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"stable" ->
|
|
D.succeed Stable
|
|
|
|
"unstable" ->
|
|
D.succeed Unstable
|
|
|
|
_ ->
|
|
D.fail "Expected one of [stable, unstable]"
|
|
)
|
|
|
|
|
|
{-| The visibility of a room to users who are not a member of the room.
|
|
-}
|
|
type RoomVisibility
|
|
= RoomPrivate
|
|
| RoomPublic
|
|
|
|
|
|
{-| Encode the RoomVisibilitytype into a JSON Value
|
|
-}
|
|
encodeRoomVisibility : RoomVisibility -> E.Value
|
|
encodeRoomVisibility =
|
|
encodeEnum fromRoomVisibility
|
|
|
|
|
|
{-| Convert the RoomVisibility type into a string.
|
|
-}
|
|
fromRoomVisibility : RoomVisibility -> String
|
|
fromRoomVisibility enum =
|
|
case enum of
|
|
RoomPrivate ->
|
|
"private"
|
|
|
|
RoomPublic ->
|
|
"public"
|
|
|
|
|
|
{-| Decodes the RoomVisibility type from a JSON String
|
|
-}
|
|
roomVisibilityDecoder : D.Decoder RoomVisibility
|
|
roomVisibilityDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"private" ->
|
|
D.succeed RoomPrivate
|
|
|
|
"public" ->
|
|
D.succeed RoomPublic
|
|
|
|
_ ->
|
|
D.fail "Expected one of [private, public]"
|
|
)
|
|
|
|
|
|
{-| The order in which to search for results.
|
|
-}
|
|
type SearchOrdering
|
|
= Recent
|
|
| Rank
|
|
|
|
|
|
{-| Encode the SearchOrderingtype into a JSON Value
|
|
-}
|
|
encodeSearchOrdering : SearchOrdering -> E.Value
|
|
encodeSearchOrdering =
|
|
encodeEnum fromSearchOrdering
|
|
|
|
|
|
{-| Convert the SearchOrdering type into a string.
|
|
-}
|
|
fromSearchOrdering : SearchOrdering -> String
|
|
fromSearchOrdering enum =
|
|
case enum of
|
|
Recent ->
|
|
"recent"
|
|
|
|
Rank ->
|
|
"rank"
|
|
|
|
|
|
{-| Decodes the SearchOrdering type from a JSON String
|
|
-}
|
|
searchOrderingDecoder : D.Decoder SearchOrdering
|
|
searchOrderingDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"recent" ->
|
|
D.succeed Recent
|
|
|
|
"rank" ->
|
|
D.succeed Rank
|
|
|
|
_ ->
|
|
D.fail "Expected one of [recent, rank]"
|
|
)
|
|
|
|
|
|
{-| A session description type.
|
|
-}
|
|
type SessionDescriptionType
|
|
= Answer
|
|
| Offer
|
|
|
|
|
|
{-| Encode the SessionDescriptionTypetype into a JSON Value
|
|
-}
|
|
encodeSessionDescriptionType : SessionDescriptionType -> E.Value
|
|
encodeSessionDescriptionType =
|
|
encodeEnum fromSessionDescriptionType
|
|
|
|
|
|
{-| Convert the SessionDescriptionType type into a string.
|
|
-}
|
|
fromSessionDescriptionType : SessionDescriptionType -> String
|
|
fromSessionDescriptionType enum =
|
|
case enum of
|
|
Answer ->
|
|
"answer"
|
|
|
|
Offer ->
|
|
"offer"
|
|
|
|
|
|
{-| Decodes the SessionDescriptionType type from a JSON String
|
|
-}
|
|
sessionDescriptionTypeDecoder : D.Decoder SessionDescriptionType
|
|
sessionDescriptionTypeDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"answer" ->
|
|
D.succeed Answer
|
|
|
|
"offer" ->
|
|
D.succeed Offer
|
|
|
|
_ ->
|
|
D.fail "Expected one of [answer, offer]"
|
|
)
|
|
|
|
|
|
{-| A 3rd party medium that a user could use for authentication.
|
|
-}
|
|
type ThirdPartyMedium
|
|
= Email
|
|
| Msisdn
|
|
|
|
|
|
{-| Encode the ThirdPartyMediumtype into a JSON Value
|
|
-}
|
|
encodeThirdPartyMedium : ThirdPartyMedium -> E.Value
|
|
encodeThirdPartyMedium =
|
|
encodeEnum fromThirdPartyMedium
|
|
|
|
|
|
{-| Convert the ThirdPartyMedium type into a string.
|
|
-}
|
|
fromThirdPartyMedium : ThirdPartyMedium -> String
|
|
fromThirdPartyMedium enum =
|
|
case enum of
|
|
Email ->
|
|
"email"
|
|
|
|
Msisdn ->
|
|
"msisdn"
|
|
|
|
|
|
{-| Decodes the ThirdPartyMedium type from a JSON String
|
|
-}
|
|
thirdPartyMediumDecoder : D.Decoder ThirdPartyMedium
|
|
thirdPartyMediumDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"email" ->
|
|
D.succeed Email
|
|
|
|
"msisdn" ->
|
|
D.succeed Msisdn
|
|
|
|
_ ->
|
|
D.fail "Expected one of [email, msisdn]"
|
|
)
|
|
|
|
|
|
{-| Reason why a key was not sent.
|
|
-}
|
|
type UnavailableKey
|
|
= BlacklistedKey
|
|
| UnverifiedKey
|
|
| UnauthorisedKey
|
|
| UnavailableKey
|
|
| NoOlm
|
|
|
|
|
|
{-| Encode the UnavailableKeytype into a JSON Value
|
|
-}
|
|
encodeUnavailableKey : UnavailableKey -> E.Value
|
|
encodeUnavailableKey =
|
|
encodeEnum fromUnavailableKey
|
|
|
|
|
|
{-| Convert the UnavailableKey type into a string.
|
|
-}
|
|
fromUnavailableKey : UnavailableKey -> String
|
|
fromUnavailableKey enum =
|
|
case enum of
|
|
BlacklistedKey ->
|
|
"m.blacklisted"
|
|
|
|
UnverifiedKey ->
|
|
"m.unverified"
|
|
|
|
UnauthorisedKey ->
|
|
"m.unauthorised"
|
|
|
|
UnavailableKey ->
|
|
"m.unavailable"
|
|
|
|
NoOlm ->
|
|
"m.no_olm"
|
|
|
|
|
|
{-| Decodes the UnavailableKey type from a JSON String
|
|
-}
|
|
unavailableKeyDecoder : D.Decoder UnavailableKey
|
|
unavailableKeyDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"m.blacklisted" ->
|
|
D.succeed BlacklistedKey
|
|
|
|
"m.unverified" ->
|
|
D.succeed UnverifiedKey
|
|
|
|
"m.unauthorised" ->
|
|
D.succeed UnauthorisedKey
|
|
|
|
"m.unavailable" ->
|
|
D.succeed UnavailableKey
|
|
|
|
"m.no_olm" ->
|
|
D.succeed NoOlm
|
|
|
|
_ ->
|
|
D.fail "Expected one of [m.blacklisted, m.unverified, m.unauthorised, m.unavailable, m.no_olm]"
|
|
)
|
|
|
|
|
|
{-| The type of user presence.
|
|
-}
|
|
type UserPresence
|
|
= Offline
|
|
| Online
|
|
| UserUnavailable
|
|
|
|
|
|
{-| Encode the UserPresencetype into a JSON Value
|
|
-}
|
|
encodeUserPresence : UserPresence -> E.Value
|
|
encodeUserPresence =
|
|
encodeEnum fromUserPresence
|
|
|
|
|
|
{-| Convert the UserPresence type into a string.
|
|
-}
|
|
fromUserPresence : UserPresence -> String
|
|
fromUserPresence enum =
|
|
case enum of
|
|
Offline ->
|
|
"offline"
|
|
|
|
Online ->
|
|
"online"
|
|
|
|
UserUnavailable ->
|
|
"unavailable"
|
|
|
|
|
|
{-| Decodes the UserPresence type from a JSON String
|
|
-}
|
|
userPresenceDecoder : D.Decoder UserPresence
|
|
userPresenceDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"offline" ->
|
|
D.succeed Offline
|
|
|
|
"online" ->
|
|
D.succeed Online
|
|
|
|
"unavailable" ->
|
|
D.succeed UserUnavailable
|
|
|
|
_ ->
|
|
D.fail "Expected one of [offline, online, unavailable]"
|
|
)
|
|
|
|
|
|
{-| Verification method to use.
|
|
-}
|
|
type VerificationMethod
|
|
= SASv1
|
|
| ReciprocateV1
|
|
|
|
|
|
{-| Encode the VerificationMethodtype into a JSON Value
|
|
-}
|
|
encodeVerificationMethod : VerificationMethod -> E.Value
|
|
encodeVerificationMethod =
|
|
encodeEnum fromVerificationMethod
|
|
|
|
|
|
{-| Convert the VerificationMethod type into a string.
|
|
-}
|
|
fromVerificationMethod : VerificationMethod -> String
|
|
fromVerificationMethod enum =
|
|
case enum of
|
|
SASv1 ->
|
|
"m.sas.v1"
|
|
|
|
ReciprocateV1 ->
|
|
"m.reciprocate.v1"
|
|
|
|
|
|
{-| Decodes the VerificationMethod type from a JSON String
|
|
-}
|
|
verificationMethodDecoder : D.Decoder VerificationMethod
|
|
verificationMethodDecoder =
|
|
decodeEnum
|
|
(\s ->
|
|
case s of
|
|
"m.sas.v1" ->
|
|
D.succeed SASv1
|
|
|
|
"m.reciprocate.v1" ->
|
|
D.succeed ReciprocateV1
|
|
|
|
_ ->
|
|
D.fail "Expected one of [m.sas.v1, m.reciprocate.v1]"
|
|
)
|
|
|
|
|
|
{-| Decode a JSON string and interpret it as an enum
|
|
-}
|
|
decodeEnum : (String -> D.Decoder a) -> D.Decoder a
|
|
decodeEnum f =
|
|
D.andThen f D.string
|
|
|
|
|
|
{-| Encode an enum into a JSON value
|
|
-}
|
|
encodeEnum : (a -> String) -> a -> E.Value
|
|
encodeEnum toString =
|
|
toString >> E.string
|