agent-push-kit-0.1.0: lib/AgentPushKit/Model.hs

{-
   Agent Push Kit API

   The complete Agent Push Kit REST API. Application event ingestion uses an organization key beginning with `apk_`. Authenticated user operations accept either an Agent Push Kit login JWT or an agent access token beginning with `apt_`.

   OpenAPI Version: 3.1.0
   Agent Push Kit API API version: 0.1.0
   Generated by OpenAPI Generator (https://openapi-generator.tech)
-}

{-|
Module : AgentPushKit.Model
-}

{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-unused-matches -fno-warn-unused-binds -fno-warn-unused-imports #-}

module AgentPushKit.Model where

import AgentPushKit.Core
import AgentPushKit.MimeTypes

import Data.Aeson ((.:),(.:!),(.:?),(.=))

import qualified Control.Arrow as P (left)
import qualified Data.Aeson as A
import qualified Data.ByteString as B
import qualified Data.ByteString.Base64 as B64
import qualified Data.ByteString.Char8 as BC
import qualified Data.ByteString.Lazy as BL
import qualified Data.Data as P (Typeable, TypeRep, typeOf, typeRep)
import qualified Data.Foldable as P
import qualified Data.HashMap.Lazy as HM
import qualified Data.Map as Map
import qualified Data.Maybe as P
import qualified Data.Set as Set
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import qualified Data.Time as TI
import qualified Lens.Micro as L
import qualified Web.FormUrlEncoded as WH
import qualified Web.HttpApiData as WH

import Control.Applicative ((<|>))
import Control.Applicative (Alternative)
import Data.Function ((&))
import Data.Monoid ((<>))
import Data.Text (Text)
import Prelude (($),(/=),(.),(<$>),(<*>),(>>=),(=<<),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)

import qualified Prelude as P

-- OpenAPI Generator 7.24 emits AnyType for free-form JSON without defining it.
-- Aeson Value is the precise representation for an arbitrary JSON value.
type AnyType = A.Value


-- * Parameter newtypes


-- ** Cursor
newtype Cursor = Cursor { unCursor :: Text } deriving (P.Eq, P.Show)

-- ** EventId
newtype EventId = EventId { unEventId :: Text } deriving (P.Eq, P.Show)

-- ** InstallationId
newtype InstallationId = InstallationId { unInstallationId :: Text } deriving (P.Eq, P.Show)

-- ** Limit
newtype Limit = Limit { unLimit :: Int } deriving (P.Eq, P.Show)

-- ** OrganizationId
newtype OrganizationId = OrganizationId { unOrganizationId :: Text } deriving (P.Eq, P.Show)

-- ** ParamType
newtype ParamType = ParamType { unParamType :: Text } deriving (P.Eq, P.Show)

-- ** RequestBody
newtype RequestBody = RequestBody { unRequestBody :: (Map.Map String AnyType) } deriving (P.Eq, P.Show, A.ToJSON)

-- ** Search
newtype Search = Search { unSearch :: Text } deriving (P.Eq, P.Show)

-- ** Service2
newtype Service2 = Service2 { unService2 :: Text } deriving (P.Eq, P.Show)

-- ** ServiceId
newtype ServiceId = ServiceId { unServiceId :: Text } deriving (P.Eq, P.Show)

-- ** SubscriptionId
newtype SubscriptionId = SubscriptionId { unSubscriptionId :: Text } deriving (P.Eq, P.Show)

-- ** TokenId
newtype TokenId = TokenId { unTokenId :: Text } deriving (P.Eq, P.Show)

-- * Models


-- ** AcceptedResponse
-- | AcceptedResponse
data AcceptedResponse = AcceptedResponse
  { acceptedResponseAccepted :: !(Bool) -- ^ /Required/ "accepted"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON AcceptedResponse
instance A.FromJSON AcceptedResponse where
  parseJSON = A.withObject "AcceptedResponse" $ \o ->
    AcceptedResponse
      <$> (o .:  "accepted")

-- | ToJSON AcceptedResponse
instance A.ToJSON AcceptedResponse where
  toJSON AcceptedResponse {..} =
   _omitNulls
      [ "accepted" .= acceptedResponseAccepted
      ]


-- | Construct a value of type 'AcceptedResponse' (by applying it's required fields, if any)
mkAcceptedResponse
  :: Bool -- ^ 'acceptedResponseAccepted' 
  -> AcceptedResponse
mkAcceptedResponse acceptedResponseAccepted =
  AcceptedResponse
  { acceptedResponseAccepted
  }

-- ** AddMemberInput
-- | AddMemberInput
data AddMemberInput = AddMemberInput
  { addMemberInputEmail :: !(Text) -- ^ /Required/ "email"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON AddMemberInput
instance A.FromJSON AddMemberInput where
  parseJSON = A.withObject "AddMemberInput" $ \o ->
    AddMemberInput
      <$> (o .:  "email")

-- | ToJSON AddMemberInput
instance A.ToJSON AddMemberInput where
  toJSON AddMemberInput {..} =
   _omitNulls
      [ "email" .= addMemberInputEmail
      ]


-- | Construct a value of type 'AddMemberInput' (by applying it's required fields, if any)
mkAddMemberInput
  :: Text -- ^ 'addMemberInputEmail' 
  -> AddMemberInput
mkAddMemberInput addMemberInputEmail =
  AddMemberInput
  { addMemberInputEmail
  }

-- ** AgentToken
-- | AgentToken
data AgentToken = AgentToken
  { agentTokenId :: !(Text) -- ^ /Required/ "id"
  , agentTokenName :: !(Text) -- ^ /Required/ "name"
  , agentTokenKeyPrefix :: !(Text) -- ^ /Required/ "keyPrefix"
  , agentTokenLastFour :: !(Text) -- ^ /Required/ "lastFour"
  , agentTokenCreatedAt :: !(DateTime) -- ^ /Required/ "createdAt"
  , agentTokenLastUsedAt :: !(Maybe DateTime) -- ^ "lastUsedAt"
  , agentTokenRevokedAt :: !(Maybe DateTime) -- ^ "revokedAt"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON AgentToken
instance A.FromJSON AgentToken where
  parseJSON = A.withObject "AgentToken" $ \o ->
    AgentToken
      <$> (o .:  "id")
      <*> (o .:  "name")
      <*> (o .:  "keyPrefix")
      <*> (o .:  "lastFour")
      <*> (o .:  "createdAt")
      <*> (o .:? "lastUsedAt")
      <*> (o .:? "revokedAt")

-- | ToJSON AgentToken
instance A.ToJSON AgentToken where
  toJSON AgentToken {..} =
   _omitNulls
      [ "id" .= agentTokenId
      , "name" .= agentTokenName
      , "keyPrefix" .= agentTokenKeyPrefix
      , "lastFour" .= agentTokenLastFour
      , "createdAt" .= agentTokenCreatedAt
      , "lastUsedAt" .= agentTokenLastUsedAt
      , "revokedAt" .= agentTokenRevokedAt
      ]


-- | Construct a value of type 'AgentToken' (by applying it's required fields, if any)
mkAgentToken
  :: Text -- ^ 'agentTokenId' 
  -> Text -- ^ 'agentTokenName' 
  -> Text -- ^ 'agentTokenKeyPrefix' 
  -> Text -- ^ 'agentTokenLastFour' 
  -> DateTime -- ^ 'agentTokenCreatedAt' 
  -> AgentToken
mkAgentToken agentTokenId agentTokenName agentTokenKeyPrefix agentTokenLastFour agentTokenCreatedAt =
  AgentToken
  { agentTokenId
  , agentTokenName
  , agentTokenKeyPrefix
  , agentTokenLastFour
  , agentTokenCreatedAt
  , agentTokenLastUsedAt = Nothing
  , agentTokenRevokedAt = Nothing
  }

-- ** AgentTokenCreated
-- | AgentTokenCreated
data AgentTokenCreated = AgentTokenCreated
  { agentTokenCreatedId :: !(Text) -- ^ /Required/ "id"
  , agentTokenCreatedName :: !(Text) -- ^ /Required/ "name"
  , agentTokenCreatedKeyPrefix :: !(Text) -- ^ /Required/ "keyPrefix"
  , agentTokenCreatedLastFour :: !(Text) -- ^ /Required/ "lastFour"
  , agentTokenCreatedCreatedAt :: !(DateTime) -- ^ /Required/ "createdAt"
  , agentTokenCreatedLastUsedAt :: !(Maybe DateTime) -- ^ "lastUsedAt"
  , agentTokenCreatedRevokedAt :: !(Maybe DateTime) -- ^ "revokedAt"
  , agentTokenCreatedToken :: !(Text) -- ^ /Required/ "token"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON AgentTokenCreated
instance A.FromJSON AgentTokenCreated where
  parseJSON = A.withObject "AgentTokenCreated" $ \o ->
    AgentTokenCreated
      <$> (o .:  "id")
      <*> (o .:  "name")
      <*> (o .:  "keyPrefix")
      <*> (o .:  "lastFour")
      <*> (o .:  "createdAt")
      <*> (o .:? "lastUsedAt")
      <*> (o .:? "revokedAt")
      <*> (o .:  "token")

-- | ToJSON AgentTokenCreated
instance A.ToJSON AgentTokenCreated where
  toJSON AgentTokenCreated {..} =
   _omitNulls
      [ "id" .= agentTokenCreatedId
      , "name" .= agentTokenCreatedName
      , "keyPrefix" .= agentTokenCreatedKeyPrefix
      , "lastFour" .= agentTokenCreatedLastFour
      , "createdAt" .= agentTokenCreatedCreatedAt
      , "lastUsedAt" .= agentTokenCreatedLastUsedAt
      , "revokedAt" .= agentTokenCreatedRevokedAt
      , "token" .= agentTokenCreatedToken
      ]


-- | Construct a value of type 'AgentTokenCreated' (by applying it's required fields, if any)
mkAgentTokenCreated
  :: Text -- ^ 'agentTokenCreatedId' 
  -> Text -- ^ 'agentTokenCreatedName' 
  -> Text -- ^ 'agentTokenCreatedKeyPrefix' 
  -> Text -- ^ 'agentTokenCreatedLastFour' 
  -> DateTime -- ^ 'agentTokenCreatedCreatedAt' 
  -> Text -- ^ 'agentTokenCreatedToken' 
  -> AgentTokenCreated
mkAgentTokenCreated agentTokenCreatedId agentTokenCreatedName agentTokenCreatedKeyPrefix agentTokenCreatedLastFour agentTokenCreatedCreatedAt agentTokenCreatedToken =
  AgentTokenCreated
  { agentTokenCreatedId
  , agentTokenCreatedName
  , agentTokenCreatedKeyPrefix
  , agentTokenCreatedLastFour
  , agentTokenCreatedCreatedAt
  , agentTokenCreatedLastUsedAt = Nothing
  , agentTokenCreatedRevokedAt = Nothing
  , agentTokenCreatedToken
  }

-- ** ApiKeySummary
-- | ApiKeySummary
data ApiKeySummary = ApiKeySummary
  { apiKeySummaryKeyPrefix :: !(Maybe Text) -- ^ "keyPrefix"
  , apiKeySummaryLastFour :: !(Maybe Text) -- ^ "lastFour"
  , apiKeySummaryUpdatedAt :: !(Maybe DateTime) -- ^ "updatedAt"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON ApiKeySummary
instance A.FromJSON ApiKeySummary where
  parseJSON = A.withObject "ApiKeySummary" $ \o ->
    ApiKeySummary
      <$> (o .:? "keyPrefix")
      <*> (o .:? "lastFour")
      <*> (o .:? "updatedAt")

-- | ToJSON ApiKeySummary
instance A.ToJSON ApiKeySummary where
  toJSON ApiKeySummary {..} =
   _omitNulls
      [ "keyPrefix" .= apiKeySummaryKeyPrefix
      , "lastFour" .= apiKeySummaryLastFour
      , "updatedAt" .= apiKeySummaryUpdatedAt
      ]


-- | Construct a value of type 'ApiKeySummary' (by applying it's required fields, if any)
mkApiKeySummary
  :: ApiKeySummary
mkApiKeySummary =
  ApiKeySummary
  { apiKeySummaryKeyPrefix = Nothing
  , apiKeySummaryLastFour = Nothing
  , apiKeySummaryUpdatedAt = Nothing
  }

-- ** AuthResponse
-- | AuthResponse
data AuthResponse = AuthResponse
  { authResponseAccessToken :: !(Text) -- ^ /Required/ "accessToken"
  , authResponseUser :: !(User) -- ^ /Required/ "user"
  , authResponseOrganizations :: !([Organization]) -- ^ /Required/ "organizations"
  , authResponseBootstrapApiKey :: !(Maybe Text) -- ^ "bootstrapApiKey" - Present only when a new customer account was created.
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON AuthResponse
instance A.FromJSON AuthResponse where
  parseJSON = A.withObject "AuthResponse" $ \o ->
    AuthResponse
      <$> (o .:  "accessToken")
      <*> (o .:  "user")
      <*> (o .:  "organizations")
      <*> (o .:? "bootstrapApiKey")

-- | ToJSON AuthResponse
instance A.ToJSON AuthResponse where
  toJSON AuthResponse {..} =
   _omitNulls
      [ "accessToken" .= authResponseAccessToken
      , "user" .= authResponseUser
      , "organizations" .= authResponseOrganizations
      , "bootstrapApiKey" .= authResponseBootstrapApiKey
      ]


-- | Construct a value of type 'AuthResponse' (by applying it's required fields, if any)
mkAuthResponse
  :: Text -- ^ 'authResponseAccessToken' 
  -> User -- ^ 'authResponseUser' 
  -> [Organization] -- ^ 'authResponseOrganizations' 
  -> AuthResponse
mkAuthResponse authResponseAccessToken authResponseUser authResponseOrganizations =
  AuthResponse
  { authResponseAccessToken
  , authResponseUser
  , authResponseOrganizations
  , authResponseBootstrapApiKey = Nothing
  }

-- ** CreateAgentTokenInput
-- | CreateAgentTokenInput
data CreateAgentTokenInput = CreateAgentTokenInput
  { createAgentTokenInputName :: !(Text) -- ^ /Required/ "name"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON CreateAgentTokenInput
instance A.FromJSON CreateAgentTokenInput where
  parseJSON = A.withObject "CreateAgentTokenInput" $ \o ->
    CreateAgentTokenInput
      <$> (o .:  "name")

-- | ToJSON CreateAgentTokenInput
instance A.ToJSON CreateAgentTokenInput where
  toJSON CreateAgentTokenInput {..} =
   _omitNulls
      [ "name" .= createAgentTokenInputName
      ]


-- | Construct a value of type 'CreateAgentTokenInput' (by applying it's required fields, if any)
mkCreateAgentTokenInput
  :: Text -- ^ 'createAgentTokenInputName' 
  -> CreateAgentTokenInput
mkCreateAgentTokenInput createAgentTokenInputName =
  CreateAgentTokenInput
  { createAgentTokenInputName
  }

-- ** CreateOrganizationInput
-- | CreateOrganizationInput
data CreateOrganizationInput = CreateOrganizationInput
  { createOrganizationInputName :: !(Text) -- ^ /Required/ "name"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON CreateOrganizationInput
instance A.FromJSON CreateOrganizationInput where
  parseJSON = A.withObject "CreateOrganizationInput" $ \o ->
    CreateOrganizationInput
      <$> (o .:  "name")

-- | ToJSON CreateOrganizationInput
instance A.ToJSON CreateOrganizationInput where
  toJSON CreateOrganizationInput {..} =
   _omitNulls
      [ "name" .= createOrganizationInputName
      ]


-- | Construct a value of type 'CreateOrganizationInput' (by applying it's required fields, if any)
mkCreateOrganizationInput
  :: Text -- ^ 'createOrganizationInputName' 
  -> CreateOrganizationInput
mkCreateOrganizationInput createOrganizationInputName =
  CreateOrganizationInput
  { createOrganizationInputName
  }

-- ** CurrentAccount
-- | CurrentAccount
data CurrentAccount = CurrentAccount
  { currentAccountUser :: !(User) -- ^ /Required/ "user"
  , currentAccountOrganizations :: !([Organization]) -- ^ /Required/ "organizations"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON CurrentAccount
instance A.FromJSON CurrentAccount where
  parseJSON = A.withObject "CurrentAccount" $ \o ->
    CurrentAccount
      <$> (o .:  "user")
      <*> (o .:  "organizations")

-- | ToJSON CurrentAccount
instance A.ToJSON CurrentAccount where
  toJSON CurrentAccount {..} =
   _omitNulls
      [ "user" .= currentAccountUser
      , "organizations" .= currentAccountOrganizations
      ]


-- | Construct a value of type 'CurrentAccount' (by applying it's required fields, if any)
mkCurrentAccount
  :: User -- ^ 'currentAccountUser' 
  -> [Organization] -- ^ 'currentAccountOrganizations' 
  -> CurrentAccount
mkCurrentAccount currentAccountUser currentAccountOrganizations =
  CurrentAccount
  { currentAccountUser
  , currentAccountOrganizations
  }

-- ** DeletedResponse
-- | DeletedResponse
data DeletedResponse = DeletedResponse
  { deletedResponseDeleted :: !(Bool) -- ^ /Required/ "deleted"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON DeletedResponse
instance A.FromJSON DeletedResponse where
  parseJSON = A.withObject "DeletedResponse" $ \o ->
    DeletedResponse
      <$> (o .:  "deleted")

-- | ToJSON DeletedResponse
instance A.ToJSON DeletedResponse where
  toJSON DeletedResponse {..} =
   _omitNulls
      [ "deleted" .= deletedResponseDeleted
      ]


-- | Construct a value of type 'DeletedResponse' (by applying it's required fields, if any)
mkDeletedResponse
  :: Bool -- ^ 'deletedResponseDeleted' 
  -> DeletedResponse
mkDeletedResponse deletedResponseDeleted =
  DeletedResponse
  { deletedResponseDeleted
  }

-- ** DeliverySummary
-- | DeliverySummary
data DeliverySummary = DeliverySummary
  { deliverySummarySent :: !(Int) -- ^ /Required/ "sent"
  , deliverySummaryFailed :: !(Int) -- ^ /Required/ "failed"
  , deliverySummarySuppressedUsers :: !(Int) -- ^ /Required/ "suppressedUsers"
  , deliverySummaryEligibleDevices :: !(Int) -- ^ /Required/ "eligibleDevices"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON DeliverySummary
instance A.FromJSON DeliverySummary where
  parseJSON = A.withObject "DeliverySummary" $ \o ->
    DeliverySummary
      <$> (o .:  "sent")
      <*> (o .:  "failed")
      <*> (o .:  "suppressedUsers")
      <*> (o .:  "eligibleDevices")

-- | ToJSON DeliverySummary
instance A.ToJSON DeliverySummary where
  toJSON DeliverySummary {..} =
   _omitNulls
      [ "sent" .= deliverySummarySent
      , "failed" .= deliverySummaryFailed
      , "suppressedUsers" .= deliverySummarySuppressedUsers
      , "eligibleDevices" .= deliverySummaryEligibleDevices
      ]


-- | Construct a value of type 'DeliverySummary' (by applying it's required fields, if any)
mkDeliverySummary
  :: Int -- ^ 'deliverySummarySent' 
  -> Int -- ^ 'deliverySummaryFailed' 
  -> Int -- ^ 'deliverySummarySuppressedUsers' 
  -> Int -- ^ 'deliverySummaryEligibleDevices' 
  -> DeliverySummary
mkDeliverySummary deliverySummarySent deliverySummaryFailed deliverySummarySuppressedUsers deliverySummaryEligibleDevices =
  DeliverySummary
  { deliverySummarySent
  , deliverySummaryFailed
  , deliverySummarySuppressedUsers
  , deliverySummaryEligibleDevices
  }

-- ** Device
-- | Device
data Device = Device
  { deviceId :: !(Text) -- ^ /Required/ "id"
  , deviceInstallationId :: !(Text) -- ^ /Required/ "installationId"
  , deviceEnvironment :: !(E'Environment) -- ^ /Required/ "environment"
  , deviceAppVersion :: !(Maybe Text) -- ^ "appVersion"
  , deviceEnabled :: !(Bool) -- ^ /Required/ "enabled"
  , deviceLastSeenAt :: !(DateTime) -- ^ /Required/ "lastSeenAt"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON Device
instance A.FromJSON Device where
  parseJSON = A.withObject "Device" $ \o ->
    Device
      <$> (o .:  "id")
      <*> (o .:  "installationId")
      <*> (o .:  "environment")
      <*> (o .:? "appVersion")
      <*> (o .:  "enabled")
      <*> (o .:  "lastSeenAt")

-- | ToJSON Device
instance A.ToJSON Device where
  toJSON Device {..} =
   _omitNulls
      [ "id" .= deviceId
      , "installationId" .= deviceInstallationId
      , "environment" .= deviceEnvironment
      , "appVersion" .= deviceAppVersion
      , "enabled" .= deviceEnabled
      , "lastSeenAt" .= deviceLastSeenAt
      ]


-- | Construct a value of type 'Device' (by applying it's required fields, if any)
mkDevice
  :: Text -- ^ 'deviceId' 
  -> Text -- ^ 'deviceInstallationId' 
  -> E'Environment -- ^ 'deviceEnvironment' 
  -> Bool -- ^ 'deviceEnabled' 
  -> DateTime -- ^ 'deviceLastSeenAt' 
  -> Device
mkDevice deviceId deviceInstallationId deviceEnvironment deviceEnabled deviceLastSeenAt =
  Device
  { deviceId
  , deviceInstallationId
  , deviceEnvironment
  , deviceAppVersion = Nothing
  , deviceEnabled
  , deviceLastSeenAt
  }

-- ** DisabledResponse
-- | DisabledResponse
data DisabledResponse = DisabledResponse
  { disabledResponseDisabled :: !(Bool) -- ^ /Required/ "disabled"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON DisabledResponse
instance A.FromJSON DisabledResponse where
  parseJSON = A.withObject "DisabledResponse" $ \o ->
    DisabledResponse
      <$> (o .:  "disabled")

-- | ToJSON DisabledResponse
instance A.ToJSON DisabledResponse where
  toJSON DisabledResponse {..} =
   _omitNulls
      [ "disabled" .= disabledResponseDisabled
      ]


-- | Construct a value of type 'DisabledResponse' (by applying it's required fields, if any)
mkDisabledResponse
  :: Bool -- ^ 'disabledResponseDisabled' 
  -> DisabledResponse
mkDisabledResponse disabledResponseDisabled =
  DisabledResponse
  { disabledResponseDisabled
  }

-- ** ErrorResponse
-- | ErrorResponse
data ErrorResponse = ErrorResponse
  { errorResponseStatusCode :: !(Int) -- ^ /Required/ "statusCode"
  , errorResponseMessage :: !(Text) -- ^ /Required/ "message"
  , errorResponseError :: !(Maybe Text) -- ^ "error"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON ErrorResponse
instance A.FromJSON ErrorResponse where
  parseJSON = A.withObject "ErrorResponse" $ \o ->
    ErrorResponse
      <$> (o .:  "statusCode")
      <*> (o .:  "message")
      <*> (o .:? "error")

-- | ToJSON ErrorResponse
instance A.ToJSON ErrorResponse where
  toJSON ErrorResponse {..} =
   _omitNulls
      [ "statusCode" .= errorResponseStatusCode
      , "message" .= errorResponseMessage
      , "error" .= errorResponseError
      ]


-- | Construct a value of type 'ErrorResponse' (by applying it's required fields, if any)
mkErrorResponse
  :: Int -- ^ 'errorResponseStatusCode' 
  -> Text -- ^ 'errorResponseMessage' 
  -> ErrorResponse
mkErrorResponse errorResponseStatusCode errorResponseMessage =
  ErrorResponse
  { errorResponseStatusCode
  , errorResponseMessage
  , errorResponseError = Nothing
  }

-- ** EventDetail
-- | EventDetail
data EventDetail = EventDetail
  { eventDetailId :: !(Text) -- ^ /Required/ "id"
  , eventDetailType :: !(Text) -- ^ /Required/ "type"
  , eventDetailTitle :: !(Text) -- ^ /Required/ "title"
  , eventDetailBody :: !(Text) -- ^ /Required/ "body"
  , eventDetailExternalId :: !(Maybe Text) -- ^ "externalId"
  , eventDetailActionUrl :: !(Maybe Text) -- ^ "actionUrl"
  , eventDetailCreatedAt :: !(DateTime) -- ^ /Required/ "createdAt"
  , eventDetailService :: !(ServiceSummary) -- ^ /Required/ "service"
  , eventDetailServiceId :: !(Text) -- ^ /Required/ "serviceId"
  , eventDetailMetadata :: !(Maybe (Map.Map String AnyType)) -- ^ "metadata"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON EventDetail
instance A.FromJSON EventDetail where
  parseJSON = A.withObject "EventDetail" $ \o ->
    EventDetail
      <$> (o .:  "id")
      <*> (o .:  "type")
      <*> (o .:  "title")
      <*> (o .:  "body")
      <*> (o .:? "externalId")
      <*> (o .:? "actionUrl")
      <*> (o .:  "createdAt")
      <*> (o .:  "service")
      <*> (o .:  "serviceId")
      <*> (o .:? "metadata")

-- | ToJSON EventDetail
instance A.ToJSON EventDetail where
  toJSON EventDetail {..} =
   _omitNulls
      [ "id" .= eventDetailId
      , "type" .= eventDetailType
      , "title" .= eventDetailTitle
      , "body" .= eventDetailBody
      , "externalId" .= eventDetailExternalId
      , "actionUrl" .= eventDetailActionUrl
      , "createdAt" .= eventDetailCreatedAt
      , "service" .= eventDetailService
      , "serviceId" .= eventDetailServiceId
      , "metadata" .= eventDetailMetadata
      ]


-- | Construct a value of type 'EventDetail' (by applying it's required fields, if any)
mkEventDetail
  :: Text -- ^ 'eventDetailId' 
  -> Text -- ^ 'eventDetailType' 
  -> Text -- ^ 'eventDetailTitle' 
  -> Text -- ^ 'eventDetailBody' 
  -> DateTime -- ^ 'eventDetailCreatedAt' 
  -> ServiceSummary -- ^ 'eventDetailService' 
  -> Text -- ^ 'eventDetailServiceId' 
  -> EventDetail
mkEventDetail eventDetailId eventDetailType eventDetailTitle eventDetailBody eventDetailCreatedAt eventDetailService eventDetailServiceId =
  EventDetail
  { eventDetailId
  , eventDetailType
  , eventDetailTitle
  , eventDetailBody
  , eventDetailExternalId = Nothing
  , eventDetailActionUrl = Nothing
  , eventDetailCreatedAt
  , eventDetailService
  , eventDetailServiceId
  , eventDetailMetadata = Nothing
  }

-- ** EventFilter
-- | EventFilter
data EventFilter = EventFilter
  { eventFilterOperator :: !(E'Operator) -- ^ /Required/ "operator"
  , eventFilterChildren :: !([EventFilter]) -- ^ /Required/ "children"
  , eventFilterChild :: !(EventFilter) -- ^ /Required/ "child"
  , eventFilterField :: !(E'Field) -- ^ /Required/ "field"
  , eventFilterComparison :: !(E'Comparison) -- ^ /Required/ "comparison"
  , eventFilterValue :: !(DateTime) -- ^ /Required/ "value"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON EventFilter
instance A.FromJSON EventFilter where
  parseJSON = A.withObject "EventFilter" $ \o ->
    EventFilter
      <$> (o .:  "operator")
      <*> (o .:  "children")
      <*> (o .:  "child")
      <*> (o .:  "field")
      <*> (o .:  "comparison")
      <*> (o .:  "value")

-- | ToJSON EventFilter
instance A.ToJSON EventFilter where
  toJSON EventFilter {..} =
   _omitNulls
      [ "operator" .= eventFilterOperator
      , "children" .= eventFilterChildren
      , "child" .= eventFilterChild
      , "field" .= eventFilterField
      , "comparison" .= eventFilterComparison
      , "value" .= eventFilterValue
      ]


-- | Construct a value of type 'EventFilter' (by applying it's required fields, if any)
mkEventFilter
  :: E'Operator -- ^ 'eventFilterOperator' 
  -> [EventFilter] -- ^ 'eventFilterChildren' 
  -> EventFilter -- ^ 'eventFilterChild' 
  -> E'Field -- ^ 'eventFilterField' 
  -> E'Comparison -- ^ 'eventFilterComparison' 
  -> DateTime -- ^ 'eventFilterValue' 
  -> EventFilter
mkEventFilter eventFilterOperator eventFilterChildren eventFilterChild eventFilterField eventFilterComparison eventFilterValue =
  EventFilter
  { eventFilterOperator
  , eventFilterChildren
  , eventFilterChild
  , eventFilterField
  , eventFilterComparison
  , eventFilterValue
  }

-- ** EventPage
-- | EventPage
data EventPage = EventPage
  { eventPageEvents :: !([EventSummary]) -- ^ /Required/ "events"
  , eventPageNextCursor :: !(Maybe Text) -- ^ "nextCursor"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON EventPage
instance A.FromJSON EventPage where
  parseJSON = A.withObject "EventPage" $ \o ->
    EventPage
      <$> (o .:  "events")
      <*> (o .:? "nextCursor")

-- | ToJSON EventPage
instance A.ToJSON EventPage where
  toJSON EventPage {..} =
   _omitNulls
      [ "events" .= eventPageEvents
      , "nextCursor" .= eventPageNextCursor
      ]


-- | Construct a value of type 'EventPage' (by applying it's required fields, if any)
mkEventPage
  :: [EventSummary] -- ^ 'eventPageEvents' 
  -> EventPage
mkEventPage eventPageEvents =
  EventPage
  { eventPageEvents
  , eventPageNextCursor = Nothing
  }

-- ** EventSummary
-- | EventSummary
data EventSummary = EventSummary
  { eventSummaryId :: !(Text) -- ^ /Required/ "id"
  , eventSummaryType :: !(Text) -- ^ /Required/ "type"
  , eventSummaryTitle :: !(Text) -- ^ /Required/ "title"
  , eventSummaryBody :: !(Text) -- ^ /Required/ "body"
  , eventSummaryExternalId :: !(Maybe Text) -- ^ "externalId"
  , eventSummaryActionUrl :: !(Maybe Text) -- ^ "actionUrl"
  , eventSummaryCreatedAt :: !(DateTime) -- ^ /Required/ "createdAt"
  , eventSummaryService :: !(ServiceSummary) -- ^ /Required/ "service"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON EventSummary
instance A.FromJSON EventSummary where
  parseJSON = A.withObject "EventSummary" $ \o ->
    EventSummary
      <$> (o .:  "id")
      <*> (o .:  "type")
      <*> (o .:  "title")
      <*> (o .:  "body")
      <*> (o .:? "externalId")
      <*> (o .:? "actionUrl")
      <*> (o .:  "createdAt")
      <*> (o .:  "service")

-- | ToJSON EventSummary
instance A.ToJSON EventSummary where
  toJSON EventSummary {..} =
   _omitNulls
      [ "id" .= eventSummaryId
      , "type" .= eventSummaryType
      , "title" .= eventSummaryTitle
      , "body" .= eventSummaryBody
      , "externalId" .= eventSummaryExternalId
      , "actionUrl" .= eventSummaryActionUrl
      , "createdAt" .= eventSummaryCreatedAt
      , "service" .= eventSummaryService
      ]


-- | Construct a value of type 'EventSummary' (by applying it's required fields, if any)
mkEventSummary
  :: Text -- ^ 'eventSummaryId' 
  -> Text -- ^ 'eventSummaryType' 
  -> Text -- ^ 'eventSummaryTitle' 
  -> Text -- ^ 'eventSummaryBody' 
  -> DateTime -- ^ 'eventSummaryCreatedAt' 
  -> ServiceSummary -- ^ 'eventSummaryService' 
  -> EventSummary
mkEventSummary eventSummaryId eventSummaryType eventSummaryTitle eventSummaryBody eventSummaryCreatedAt eventSummaryService =
  EventSummary
  { eventSummaryId
  , eventSummaryType
  , eventSummaryTitle
  , eventSummaryBody
  , eventSummaryExternalId = Nothing
  , eventSummaryActionUrl = Nothing
  , eventSummaryCreatedAt
  , eventSummaryService
  }

-- ** FilterGroup
-- | FilterGroup
data FilterGroup = FilterGroup
  { filterGroupOperator :: !(E'Operator2) -- ^ /Required/ "operator"
  , filterGroupChildren :: !([EventFilter]) -- ^ /Required/ "children"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON FilterGroup
instance A.FromJSON FilterGroup where
  parseJSON = A.withObject "FilterGroup" $ \o ->
    FilterGroup
      <$> (o .:  "operator")
      <*> (o .:  "children")

-- | ToJSON FilterGroup
instance A.ToJSON FilterGroup where
  toJSON FilterGroup {..} =
   _omitNulls
      [ "operator" .= filterGroupOperator
      , "children" .= filterGroupChildren
      ]


-- | Construct a value of type 'FilterGroup' (by applying it's required fields, if any)
mkFilterGroup
  :: E'Operator2 -- ^ 'filterGroupOperator' 
  -> [EventFilter] -- ^ 'filterGroupChildren' 
  -> FilterGroup
mkFilterGroup filterGroupOperator filterGroupChildren =
  FilterGroup
  { filterGroupOperator
  , filterGroupChildren
  }

-- ** FilterNot
-- | FilterNot
data FilterNot = FilterNot
  { filterNotOperator :: !(E'Operator) -- ^ /Required/ "operator"
  , filterNotChild :: !(EventFilter) -- ^ /Required/ "child"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON FilterNot
instance A.FromJSON FilterNot where
  parseJSON = A.withObject "FilterNot" $ \o ->
    FilterNot
      <$> (o .:  "operator")
      <*> (o .:  "child")

-- | ToJSON FilterNot
instance A.ToJSON FilterNot where
  toJSON FilterNot {..} =
   _omitNulls
      [ "operator" .= filterNotOperator
      , "child" .= filterNotChild
      ]


-- | Construct a value of type 'FilterNot' (by applying it's required fields, if any)
mkFilterNot
  :: E'Operator -- ^ 'filterNotOperator' 
  -> EventFilter -- ^ 'filterNotChild' 
  -> FilterNot
mkFilterNot filterNotOperator filterNotChild =
  FilterNot
  { filterNotOperator
  , filterNotChild
  }

-- ** HealthResponse
-- | HealthResponse
data HealthResponse = HealthResponse
  { healthResponseStatus :: !(E'Status) -- ^ /Required/ "status"
  , healthResponseService :: !(E'Service) -- ^ /Required/ "service"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON HealthResponse
instance A.FromJSON HealthResponse where
  parseJSON = A.withObject "HealthResponse" $ \o ->
    HealthResponse
      <$> (o .:  "status")
      <*> (o .:  "service")

-- | ToJSON HealthResponse
instance A.ToJSON HealthResponse where
  toJSON HealthResponse {..} =
   _omitNulls
      [ "status" .= healthResponseStatus
      , "service" .= healthResponseService
      ]


-- | Construct a value of type 'HealthResponse' (by applying it's required fields, if any)
mkHealthResponse
  :: E'Status -- ^ 'healthResponseStatus' 
  -> E'Service -- ^ 'healthResponseService' 
  -> HealthResponse
mkHealthResponse healthResponseStatus healthResponseService =
  HealthResponse
  { healthResponseStatus
  , healthResponseService
  }

-- ** IngestionResult
-- | IngestionResult
data IngestionResult = IngestionResult
  { ingestionResultEvent :: !(EventDetail) -- ^ /Required/ "event"
  , ingestionResultDuplicate :: !(Bool) -- ^ /Required/ "duplicate"
  , ingestionResultDelivery :: !(DeliverySummary) -- ^ /Required/ "delivery"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON IngestionResult
instance A.FromJSON IngestionResult where
  parseJSON = A.withObject "IngestionResult" $ \o ->
    IngestionResult
      <$> (o .:  "event")
      <*> (o .:  "duplicate")
      <*> (o .:  "delivery")

-- | ToJSON IngestionResult
instance A.ToJSON IngestionResult where
  toJSON IngestionResult {..} =
   _omitNulls
      [ "event" .= ingestionResultEvent
      , "duplicate" .= ingestionResultDuplicate
      , "delivery" .= ingestionResultDelivery
      ]


-- | Construct a value of type 'IngestionResult' (by applying it's required fields, if any)
mkIngestionResult
  :: EventDetail -- ^ 'ingestionResultEvent' 
  -> Bool -- ^ 'ingestionResultDuplicate' 
  -> DeliverySummary -- ^ 'ingestionResultDelivery' 
  -> IngestionResult
mkIngestionResult ingestionResultEvent ingestionResultDuplicate ingestionResultDelivery =
  IngestionResult
  { ingestionResultEvent
  , ingestionResultDuplicate
  , ingestionResultDelivery
  }

-- ** InheritedResponse
-- | InheritedResponse
data InheritedResponse = InheritedResponse
  { inheritedResponseInherited :: !(Bool) -- ^ /Required/ "inherited"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON InheritedResponse
instance A.FromJSON InheritedResponse where
  parseJSON = A.withObject "InheritedResponse" $ \o ->
    InheritedResponse
      <$> (o .:  "inherited")

-- | ToJSON InheritedResponse
instance A.ToJSON InheritedResponse where
  toJSON InheritedResponse {..} =
   _omitNulls
      [ "inherited" .= inheritedResponseInherited
      ]


-- | Construct a value of type 'InheritedResponse' (by applying it's required fields, if any)
mkInheritedResponse
  :: Bool -- ^ 'inheritedResponseInherited' 
  -> InheritedResponse
mkInheritedResponse inheritedResponseInherited =
  InheritedResponse
  { inheritedResponseInherited
  }

-- ** Membership
-- | Membership
data Membership = Membership
  { membershipId :: !(Text) -- ^ /Required/ "id"
  , membershipRole :: !(E'Role) -- ^ /Required/ "role"
  , membershipCreatedAt :: !(DateTime) -- ^ /Required/ "createdAt"
  , membershipUser :: !(MembershipUser) -- ^ /Required/ "user"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON Membership
instance A.FromJSON Membership where
  parseJSON = A.withObject "Membership" $ \o ->
    Membership
      <$> (o .:  "id")
      <*> (o .:  "role")
      <*> (o .:  "createdAt")
      <*> (o .:  "user")

-- | ToJSON Membership
instance A.ToJSON Membership where
  toJSON Membership {..} =
   _omitNulls
      [ "id" .= membershipId
      , "role" .= membershipRole
      , "createdAt" .= membershipCreatedAt
      , "user" .= membershipUser
      ]


-- | Construct a value of type 'Membership' (by applying it's required fields, if any)
mkMembership
  :: Text -- ^ 'membershipId' 
  -> E'Role -- ^ 'membershipRole' 
  -> DateTime -- ^ 'membershipCreatedAt' 
  -> MembershipUser -- ^ 'membershipUser' 
  -> Membership
mkMembership membershipId membershipRole membershipCreatedAt membershipUser =
  Membership
  { membershipId
  , membershipRole
  , membershipCreatedAt
  , membershipUser
  }

-- ** MembershipUser
-- | MembershipUser
data MembershipUser = MembershipUser
  { membershipUserId :: !(Text) -- ^ /Required/ "id"
  , membershipUserEmail :: !(Text) -- ^ /Required/ "email"
  , membershipUserDisplayName :: !(Maybe Text) -- ^ "displayName"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON MembershipUser
instance A.FromJSON MembershipUser where
  parseJSON = A.withObject "MembershipUser" $ \o ->
    MembershipUser
      <$> (o .:  "id")
      <*> (o .:  "email")
      <*> (o .:? "displayName")

-- | ToJSON MembershipUser
instance A.ToJSON MembershipUser where
  toJSON MembershipUser {..} =
   _omitNulls
      [ "id" .= membershipUserId
      , "email" .= membershipUserEmail
      , "displayName" .= membershipUserDisplayName
      ]


-- | Construct a value of type 'MembershipUser' (by applying it's required fields, if any)
mkMembershipUser
  :: Text -- ^ 'membershipUserId' 
  -> Text -- ^ 'membershipUserEmail' 
  -> MembershipUser
mkMembershipUser membershipUserId membershipUserEmail =
  MembershipUser
  { membershipUserId
  , membershipUserEmail
  , membershipUserDisplayName = Nothing
  }

-- ** Organization
-- | Organization
data Organization = Organization
  { organizationId :: !(Text) -- ^ /Required/ "id"
  , organizationName :: !(Text) -- ^ /Required/ "name"
  , organizationRole :: !(E'Role) -- ^ /Required/ "role"
  , organizationCreatedAt :: !(DateTime) -- ^ /Required/ "createdAt"
  , organizationUpdatedAt :: !(DateTime) -- ^ /Required/ "updatedAt"
  , organizationJoinedAt :: !(DateTime) -- ^ /Required/ "joinedAt"
  , organizationApiKey :: !(Maybe ApiKeySummary) -- ^ "apiKey"
  , organizationCount :: !(Maybe OrganizationCount) -- ^ "_count"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON Organization
instance A.FromJSON Organization where
  parseJSON = A.withObject "Organization" $ \o ->
    Organization
      <$> (o .:  "id")
      <*> (o .:  "name")
      <*> (o .:  "role")
      <*> (o .:  "createdAt")
      <*> (o .:  "updatedAt")
      <*> (o .:  "joinedAt")
      <*> (o .:? "apiKey")
      <*> (o .:? "_count")

-- | ToJSON Organization
instance A.ToJSON Organization where
  toJSON Organization {..} =
   _omitNulls
      [ "id" .= organizationId
      , "name" .= organizationName
      , "role" .= organizationRole
      , "createdAt" .= organizationCreatedAt
      , "updatedAt" .= organizationUpdatedAt
      , "joinedAt" .= organizationJoinedAt
      , "apiKey" .= organizationApiKey
      , "_count" .= organizationCount
      ]


-- | Construct a value of type 'Organization' (by applying it's required fields, if any)
mkOrganization
  :: Text -- ^ 'organizationId' 
  -> Text -- ^ 'organizationName' 
  -> E'Role -- ^ 'organizationRole' 
  -> DateTime -- ^ 'organizationCreatedAt' 
  -> DateTime -- ^ 'organizationUpdatedAt' 
  -> DateTime -- ^ 'organizationJoinedAt' 
  -> Organization
mkOrganization organizationId organizationName organizationRole organizationCreatedAt organizationUpdatedAt organizationJoinedAt =
  Organization
  { organizationId
  , organizationName
  , organizationRole
  , organizationCreatedAt
  , organizationUpdatedAt
  , organizationJoinedAt
  , organizationApiKey = Nothing
  , organizationCount = Nothing
  }

-- ** OrganizationApiKeyCreated
-- | OrganizationApiKeyCreated
data OrganizationApiKeyCreated = OrganizationApiKeyCreated
  { organizationApiKeyCreatedKeyPrefix :: !(Text) -- ^ /Required/ "keyPrefix"
  , organizationApiKeyCreatedLastFour :: !(Text) -- ^ /Required/ "lastFour"
  , organizationApiKeyCreatedUpdatedAt :: !(DateTime) -- ^ /Required/ "updatedAt"
  , organizationApiKeyCreatedApiKey :: !(Text) -- ^ /Required/ "apiKey"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON OrganizationApiKeyCreated
instance A.FromJSON OrganizationApiKeyCreated where
  parseJSON = A.withObject "OrganizationApiKeyCreated" $ \o ->
    OrganizationApiKeyCreated
      <$> (o .:  "keyPrefix")
      <*> (o .:  "lastFour")
      <*> (o .:  "updatedAt")
      <*> (o .:  "apiKey")

-- | ToJSON OrganizationApiKeyCreated
instance A.ToJSON OrganizationApiKeyCreated where
  toJSON OrganizationApiKeyCreated {..} =
   _omitNulls
      [ "keyPrefix" .= organizationApiKeyCreatedKeyPrefix
      , "lastFour" .= organizationApiKeyCreatedLastFour
      , "updatedAt" .= organizationApiKeyCreatedUpdatedAt
      , "apiKey" .= organizationApiKeyCreatedApiKey
      ]


-- | Construct a value of type 'OrganizationApiKeyCreated' (by applying it's required fields, if any)
mkOrganizationApiKeyCreated
  :: Text -- ^ 'organizationApiKeyCreatedKeyPrefix' 
  -> Text -- ^ 'organizationApiKeyCreatedLastFour' 
  -> DateTime -- ^ 'organizationApiKeyCreatedUpdatedAt' 
  -> Text -- ^ 'organizationApiKeyCreatedApiKey' 
  -> OrganizationApiKeyCreated
mkOrganizationApiKeyCreated organizationApiKeyCreatedKeyPrefix organizationApiKeyCreatedLastFour organizationApiKeyCreatedUpdatedAt organizationApiKeyCreatedApiKey =
  OrganizationApiKeyCreated
  { organizationApiKeyCreatedKeyPrefix
  , organizationApiKeyCreatedLastFour
  , organizationApiKeyCreatedUpdatedAt
  , organizationApiKeyCreatedApiKey
  }

-- ** OrganizationCount
-- | OrganizationCount
data OrganizationCount = OrganizationCount
  { organizationCountMemberships :: !(Maybe Int) -- ^ "memberships"
  , organizationCountServices :: !(Maybe Int) -- ^ "services"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON OrganizationCount
instance A.FromJSON OrganizationCount where
  parseJSON = A.withObject "OrganizationCount" $ \o ->
    OrganizationCount
      <$> (o .:? "memberships")
      <*> (o .:? "services")

-- | ToJSON OrganizationCount
instance A.ToJSON OrganizationCount where
  toJSON OrganizationCount {..} =
   _omitNulls
      [ "memberships" .= organizationCountMemberships
      , "services" .= organizationCountServices
      ]


-- | Construct a value of type 'OrganizationCount' (by applying it's required fields, if any)
mkOrganizationCount
  :: OrganizationCount
mkOrganizationCount =
  OrganizationCount
  { organizationCountMemberships = Nothing
  , organizationCountServices = Nothing
  }

-- ** OrganizationCreated
-- | OrganizationCreated
data OrganizationCreated = OrganizationCreated
  { organizationCreatedOrganization :: !(OrganizationRecord) -- ^ /Required/ "organization"
  , organizationCreatedApiKey :: !(Text) -- ^ /Required/ "apiKey"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON OrganizationCreated
instance A.FromJSON OrganizationCreated where
  parseJSON = A.withObject "OrganizationCreated" $ \o ->
    OrganizationCreated
      <$> (o .:  "organization")
      <*> (o .:  "apiKey")

-- | ToJSON OrganizationCreated
instance A.ToJSON OrganizationCreated where
  toJSON OrganizationCreated {..} =
   _omitNulls
      [ "organization" .= organizationCreatedOrganization
      , "apiKey" .= organizationCreatedApiKey
      ]


-- | Construct a value of type 'OrganizationCreated' (by applying it's required fields, if any)
mkOrganizationCreated
  :: OrganizationRecord -- ^ 'organizationCreatedOrganization' 
  -> Text -- ^ 'organizationCreatedApiKey' 
  -> OrganizationCreated
mkOrganizationCreated organizationCreatedOrganization organizationCreatedApiKey =
  OrganizationCreated
  { organizationCreatedOrganization
  , organizationCreatedApiKey
  }

-- ** OrganizationRecord
-- | OrganizationRecord
data OrganizationRecord = OrganizationRecord
  { organizationRecordId :: !(Text) -- ^ /Required/ "id"
  , organizationRecordName :: !(Text) -- ^ /Required/ "name"
  , organizationRecordCreatedAt :: !(DateTime) -- ^ /Required/ "createdAt"
  , organizationRecordUpdatedAt :: !(DateTime) -- ^ /Required/ "updatedAt"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON OrganizationRecord
instance A.FromJSON OrganizationRecord where
  parseJSON = A.withObject "OrganizationRecord" $ \o ->
    OrganizationRecord
      <$> (o .:  "id")
      <*> (o .:  "name")
      <*> (o .:  "createdAt")
      <*> (o .:  "updatedAt")

-- | ToJSON OrganizationRecord
instance A.ToJSON OrganizationRecord where
  toJSON OrganizationRecord {..} =
   _omitNulls
      [ "id" .= organizationRecordId
      , "name" .= organizationRecordName
      , "createdAt" .= organizationRecordCreatedAt
      , "updatedAt" .= organizationRecordUpdatedAt
      ]


-- | Construct a value of type 'OrganizationRecord' (by applying it's required fields, if any)
mkOrganizationRecord
  :: Text -- ^ 'organizationRecordId' 
  -> Text -- ^ 'organizationRecordName' 
  -> DateTime -- ^ 'organizationRecordCreatedAt' 
  -> DateTime -- ^ 'organizationRecordUpdatedAt' 
  -> OrganizationRecord
mkOrganizationRecord organizationRecordId organizationRecordName organizationRecordCreatedAt organizationRecordUpdatedAt =
  OrganizationRecord
  { organizationRecordId
  , organizationRecordName
  , organizationRecordCreatedAt
  , organizationRecordUpdatedAt
  }

-- ** PasswordLoginInput
-- | PasswordLoginInput
data PasswordLoginInput = PasswordLoginInput
  { passwordLoginInputEmail :: !(Text) -- ^ /Required/ "email"
  , passwordLoginInputPassword :: !(Text) -- ^ /Required/ "password"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON PasswordLoginInput
instance A.FromJSON PasswordLoginInput where
  parseJSON = A.withObject "PasswordLoginInput" $ \o ->
    PasswordLoginInput
      <$> (o .:  "email")
      <*> (o .:  "password")

-- | ToJSON PasswordLoginInput
instance A.ToJSON PasswordLoginInput where
  toJSON PasswordLoginInput {..} =
   _omitNulls
      [ "email" .= passwordLoginInputEmail
      , "password" .= passwordLoginInputPassword
      ]


-- | Construct a value of type 'PasswordLoginInput' (by applying it's required fields, if any)
mkPasswordLoginInput
  :: Text -- ^ 'passwordLoginInputEmail' 
  -> Text -- ^ 'passwordLoginInputPassword' 
  -> PasswordLoginInput
mkPasswordLoginInput passwordLoginInputEmail passwordLoginInputPassword =
  PasswordLoginInput
  { passwordLoginInputEmail
  , passwordLoginInputPassword
  }

-- ** PasswordResetCompleteInput
-- | PasswordResetCompleteInput
data PasswordResetCompleteInput = PasswordResetCompleteInput
  { passwordResetCompleteInputToken :: !(Text) -- ^ /Required/ "token"
  , passwordResetCompleteInputPassword :: !(Text) -- ^ /Required/ "password"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON PasswordResetCompleteInput
instance A.FromJSON PasswordResetCompleteInput where
  parseJSON = A.withObject "PasswordResetCompleteInput" $ \o ->
    PasswordResetCompleteInput
      <$> (o .:  "token")
      <*> (o .:  "password")

-- | ToJSON PasswordResetCompleteInput
instance A.ToJSON PasswordResetCompleteInput where
  toJSON PasswordResetCompleteInput {..} =
   _omitNulls
      [ "token" .= passwordResetCompleteInputToken
      , "password" .= passwordResetCompleteInputPassword
      ]


-- | Construct a value of type 'PasswordResetCompleteInput' (by applying it's required fields, if any)
mkPasswordResetCompleteInput
  :: Text -- ^ 'passwordResetCompleteInputToken' 
  -> Text -- ^ 'passwordResetCompleteInputPassword' 
  -> PasswordResetCompleteInput
mkPasswordResetCompleteInput passwordResetCompleteInputToken passwordResetCompleteInputPassword =
  PasswordResetCompleteInput
  { passwordResetCompleteInputToken
  , passwordResetCompleteInputPassword
  }

-- ** PasswordResetRequestInput
-- | PasswordResetRequestInput
data PasswordResetRequestInput = PasswordResetRequestInput
  { passwordResetRequestInputEmail :: !(Text) -- ^ /Required/ "email"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON PasswordResetRequestInput
instance A.FromJSON PasswordResetRequestInput where
  parseJSON = A.withObject "PasswordResetRequestInput" $ \o ->
    PasswordResetRequestInput
      <$> (o .:  "email")

-- | ToJSON PasswordResetRequestInput
instance A.ToJSON PasswordResetRequestInput where
  toJSON PasswordResetRequestInput {..} =
   _omitNulls
      [ "email" .= passwordResetRequestInputEmail
      ]


-- | Construct a value of type 'PasswordResetRequestInput' (by applying it's required fields, if any)
mkPasswordResetRequestInput
  :: Text -- ^ 'passwordResetRequestInputEmail' 
  -> PasswordResetRequestInput
mkPasswordResetRequestInput passwordResetRequestInputEmail =
  PasswordResetRequestInput
  { passwordResetRequestInputEmail
  }

-- ** PreferenceRecord
-- | PreferenceRecord
data PreferenceRecord = PreferenceRecord
  { preferenceRecordServiceId :: !(Text) -- ^ /Required/ "serviceId"
  , preferenceRecordTypeKey :: !(Text) -- ^ /Required/ "typeKey"
  , preferenceRecordEnabled :: !(Bool) -- ^ /Required/ "enabled"
  , preferenceRecordUpdatedAt :: !(DateTime) -- ^ /Required/ "updatedAt"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON PreferenceRecord
instance A.FromJSON PreferenceRecord where
  parseJSON = A.withObject "PreferenceRecord" $ \o ->
    PreferenceRecord
      <$> (o .:  "serviceId")
      <*> (o .:  "typeKey")
      <*> (o .:  "enabled")
      <*> (o .:  "updatedAt")

-- | ToJSON PreferenceRecord
instance A.ToJSON PreferenceRecord where
  toJSON PreferenceRecord {..} =
   _omitNulls
      [ "serviceId" .= preferenceRecordServiceId
      , "typeKey" .= preferenceRecordTypeKey
      , "enabled" .= preferenceRecordEnabled
      , "updatedAt" .= preferenceRecordUpdatedAt
      ]


-- | Construct a value of type 'PreferenceRecord' (by applying it's required fields, if any)
mkPreferenceRecord
  :: Text -- ^ 'preferenceRecordServiceId' 
  -> Text -- ^ 'preferenceRecordTypeKey' 
  -> Bool -- ^ 'preferenceRecordEnabled' 
  -> DateTime -- ^ 'preferenceRecordUpdatedAt' 
  -> PreferenceRecord
mkPreferenceRecord preferenceRecordServiceId preferenceRecordTypeKey preferenceRecordEnabled preferenceRecordUpdatedAt =
  PreferenceRecord
  { preferenceRecordServiceId
  , preferenceRecordTypeKey
  , preferenceRecordEnabled
  , preferenceRecordUpdatedAt
  }

-- ** ProviderLoginInput
-- | ProviderLoginInput
data ProviderLoginInput = ProviderLoginInput
  { providerLoginInputIdToken :: !(Text) -- ^ /Required/ "idToken"
  , providerLoginInputDisplayName :: !(Maybe Text) -- ^ "displayName"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON ProviderLoginInput
instance A.FromJSON ProviderLoginInput where
  parseJSON = A.withObject "ProviderLoginInput" $ \o ->
    ProviderLoginInput
      <$> (o .:  "idToken")
      <*> (o .:? "displayName")

-- | ToJSON ProviderLoginInput
instance A.ToJSON ProviderLoginInput where
  toJSON ProviderLoginInput {..} =
   _omitNulls
      [ "idToken" .= providerLoginInputIdToken
      , "displayName" .= providerLoginInputDisplayName
      ]


-- | Construct a value of type 'ProviderLoginInput' (by applying it's required fields, if any)
mkProviderLoginInput
  :: Text -- ^ 'providerLoginInputIdToken' 
  -> ProviderLoginInput
mkProviderLoginInput providerLoginInputIdToken =
  ProviderLoginInput
  { providerLoginInputIdToken
  , providerLoginInputDisplayName = Nothing
  }

-- ** RegisterDeviceInput
-- | RegisterDeviceInput
data RegisterDeviceInput = RegisterDeviceInput
  { registerDeviceInputDeviceToken :: !(Text) -- ^ /Required/ "deviceToken"
  , registerDeviceInputInstallationId :: !(Text) -- ^ /Required/ "installationId"
  , registerDeviceInputEnvironment :: !(E'Environment) -- ^ /Required/ "environment"
  , registerDeviceInputAppVersion :: !(Maybe Text) -- ^ "appVersion"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON RegisterDeviceInput
instance A.FromJSON RegisterDeviceInput where
  parseJSON = A.withObject "RegisterDeviceInput" $ \o ->
    RegisterDeviceInput
      <$> (o .:  "deviceToken")
      <*> (o .:  "installationId")
      <*> (o .:  "environment")
      <*> (o .:? "appVersion")

-- | ToJSON RegisterDeviceInput
instance A.ToJSON RegisterDeviceInput where
  toJSON RegisterDeviceInput {..} =
   _omitNulls
      [ "deviceToken" .= registerDeviceInputDeviceToken
      , "installationId" .= registerDeviceInputInstallationId
      , "environment" .= registerDeviceInputEnvironment
      , "appVersion" .= registerDeviceInputAppVersion
      ]


-- | Construct a value of type 'RegisterDeviceInput' (by applying it's required fields, if any)
mkRegisterDeviceInput
  :: Text -- ^ 'registerDeviceInputDeviceToken' 
  -> Text -- ^ 'registerDeviceInputInstallationId' 
  -> E'Environment -- ^ 'registerDeviceInputEnvironment' 
  -> RegisterDeviceInput
mkRegisterDeviceInput registerDeviceInputDeviceToken registerDeviceInputInstallationId registerDeviceInputEnvironment =
  RegisterDeviceInput
  { registerDeviceInputDeviceToken
  , registerDeviceInputInstallationId
  , registerDeviceInputEnvironment
  , registerDeviceInputAppVersion = Nothing
  }

-- ** RegisterInput
-- | RegisterInput
data RegisterInput = RegisterInput
  { registerInputEmail :: !(Text) -- ^ /Required/ "email"
  , registerInputPassword :: !(Text) -- ^ /Required/ "password"
  , registerInputDisplayName :: !(Maybe Text) -- ^ "displayName"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON RegisterInput
instance A.FromJSON RegisterInput where
  parseJSON = A.withObject "RegisterInput" $ \o ->
    RegisterInput
      <$> (o .:  "email")
      <*> (o .:  "password")
      <*> (o .:? "displayName")

-- | ToJSON RegisterInput
instance A.ToJSON RegisterInput where
  toJSON RegisterInput {..} =
   _omitNulls
      [ "email" .= registerInputEmail
      , "password" .= registerInputPassword
      , "displayName" .= registerInputDisplayName
      ]


-- | Construct a value of type 'RegisterInput' (by applying it's required fields, if any)
mkRegisterInput
  :: Text -- ^ 'registerInputEmail' 
  -> Text -- ^ 'registerInputPassword' 
  -> RegisterInput
mkRegisterInput registerInputEmail registerInputPassword =
  RegisterInput
  { registerInputEmail
  , registerInputPassword
  , registerInputDisplayName = Nothing
  }

-- ** RegisterWebPushSubscriptionInput
-- | RegisterWebPushSubscriptionInput
data RegisterWebPushSubscriptionInput = RegisterWebPushSubscriptionInput
  { registerWebPushSubscriptionInputEndpoint :: !(Text) -- ^ /Required/ "endpoint"
  , registerWebPushSubscriptionInputKeys :: !(RegisterWebPushSubscriptionInputKeys) -- ^ /Required/ "keys"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON RegisterWebPushSubscriptionInput
instance A.FromJSON RegisterWebPushSubscriptionInput where
  parseJSON = A.withObject "RegisterWebPushSubscriptionInput" $ \o ->
    RegisterWebPushSubscriptionInput
      <$> (o .:  "endpoint")
      <*> (o .:  "keys")

-- | ToJSON RegisterWebPushSubscriptionInput
instance A.ToJSON RegisterWebPushSubscriptionInput where
  toJSON RegisterWebPushSubscriptionInput {..} =
   _omitNulls
      [ "endpoint" .= registerWebPushSubscriptionInputEndpoint
      , "keys" .= registerWebPushSubscriptionInputKeys
      ]


-- | Construct a value of type 'RegisterWebPushSubscriptionInput' (by applying it's required fields, if any)
mkRegisterWebPushSubscriptionInput
  :: Text -- ^ 'registerWebPushSubscriptionInputEndpoint' 
  -> RegisterWebPushSubscriptionInputKeys -- ^ 'registerWebPushSubscriptionInputKeys' 
  -> RegisterWebPushSubscriptionInput
mkRegisterWebPushSubscriptionInput registerWebPushSubscriptionInputEndpoint registerWebPushSubscriptionInputKeys =
  RegisterWebPushSubscriptionInput
  { registerWebPushSubscriptionInputEndpoint
  , registerWebPushSubscriptionInputKeys
  }

-- ** RegisterWebPushSubscriptionInputKeys
-- | RegisterWebPushSubscriptionInputKeys
data RegisterWebPushSubscriptionInputKeys = RegisterWebPushSubscriptionInputKeys
  { registerWebPushSubscriptionInputKeysP256dh :: !(Text) -- ^ /Required/ "p256dh"
  , registerWebPushSubscriptionInputKeysAuth :: !(Text) -- ^ /Required/ "auth"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON RegisterWebPushSubscriptionInputKeys
instance A.FromJSON RegisterWebPushSubscriptionInputKeys where
  parseJSON = A.withObject "RegisterWebPushSubscriptionInputKeys" $ \o ->
    RegisterWebPushSubscriptionInputKeys
      <$> (o .:  "p256dh")
      <*> (o .:  "auth")

-- | ToJSON RegisterWebPushSubscriptionInputKeys
instance A.ToJSON RegisterWebPushSubscriptionInputKeys where
  toJSON RegisterWebPushSubscriptionInputKeys {..} =
   _omitNulls
      [ "p256dh" .= registerWebPushSubscriptionInputKeysP256dh
      , "auth" .= registerWebPushSubscriptionInputKeysAuth
      ]


-- | Construct a value of type 'RegisterWebPushSubscriptionInputKeys' (by applying it's required fields, if any)
mkRegisterWebPushSubscriptionInputKeys
  :: Text -- ^ 'registerWebPushSubscriptionInputKeysP256dh' 
  -> Text -- ^ 'registerWebPushSubscriptionInputKeysAuth' 
  -> RegisterWebPushSubscriptionInputKeys
mkRegisterWebPushSubscriptionInputKeys registerWebPushSubscriptionInputKeysP256dh registerWebPushSubscriptionInputKeysAuth =
  RegisterWebPushSubscriptionInputKeys
  { registerWebPushSubscriptionInputKeysP256dh
  , registerWebPushSubscriptionInputKeysAuth
  }

-- ** RevokedResponse
-- | RevokedResponse
data RevokedResponse = RevokedResponse
  { revokedResponseRevoked :: !(Bool) -- ^ /Required/ "revoked"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON RevokedResponse
instance A.FromJSON RevokedResponse where
  parseJSON = A.withObject "RevokedResponse" $ \o ->
    RevokedResponse
      <$> (o .:  "revoked")

-- | ToJSON RevokedResponse
instance A.ToJSON RevokedResponse where
  toJSON RevokedResponse {..} =
   _omitNulls
      [ "revoked" .= revokedResponseRevoked
      ]


-- | Construct a value of type 'RevokedResponse' (by applying it's required fields, if any)
mkRevokedResponse
  :: Bool -- ^ 'revokedResponseRevoked' 
  -> RevokedResponse
mkRevokedResponse revokedResponseRevoked =
  RevokedResponse
  { revokedResponseRevoked
  }

-- ** SearchEventsInput
-- | SearchEventsInput
data SearchEventsInput = SearchEventsInput
  { searchEventsInputFilter :: !(EventFilter) -- ^ /Required/ "filter"
  , searchEventsInputCursor :: !(Maybe Text) -- ^ "cursor"
  , searchEventsInputLimit :: !(Maybe Int) -- ^ "limit"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON SearchEventsInput
instance A.FromJSON SearchEventsInput where
  parseJSON = A.withObject "SearchEventsInput" $ \o ->
    SearchEventsInput
      <$> (o .:  "filter")
      <*> (o .:? "cursor")
      <*> (o .:? "limit")

-- | ToJSON SearchEventsInput
instance A.ToJSON SearchEventsInput where
  toJSON SearchEventsInput {..} =
   _omitNulls
      [ "filter" .= searchEventsInputFilter
      , "cursor" .= searchEventsInputCursor
      , "limit" .= searchEventsInputLimit
      ]


-- | Construct a value of type 'SearchEventsInput' (by applying it's required fields, if any)
mkSearchEventsInput
  :: EventFilter -- ^ 'searchEventsInputFilter' 
  -> SearchEventsInput
mkSearchEventsInput searchEventsInputFilter =
  SearchEventsInput
  { searchEventsInputFilter
  , searchEventsInputCursor = Nothing
  , searchEventsInputLimit = Nothing
  }

-- ** SendEventInput
-- | SendEventInput
data SendEventInput = SendEventInput
  { sendEventInputService :: !(Text) -- ^ /Required/ "service"
  , sendEventInputServiceDisplayName :: !(Maybe Text) -- ^ "serviceDisplayName"
  , sendEventInputType :: !(Text) -- ^ /Required/ "type"
  , sendEventInputTitle :: !(Text) -- ^ /Required/ "title"
  , sendEventInputBody :: !(Text) -- ^ /Required/ "body"
  , sendEventInputMetadata :: !(Maybe (Map.Map String AnyType)) -- ^ "metadata"
  , sendEventInputExternalId :: !(Maybe Text) -- ^ "externalId"
  , sendEventInputActionUrl :: !(Maybe Text) -- ^ "actionUrl"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON SendEventInput
instance A.FromJSON SendEventInput where
  parseJSON = A.withObject "SendEventInput" $ \o ->
    SendEventInput
      <$> (o .:  "service")
      <*> (o .:? "serviceDisplayName")
      <*> (o .:  "type")
      <*> (o .:  "title")
      <*> (o .:  "body")
      <*> (o .:? "metadata")
      <*> (o .:? "externalId")
      <*> (o .:? "actionUrl")

-- | ToJSON SendEventInput
instance A.ToJSON SendEventInput where
  toJSON SendEventInput {..} =
   _omitNulls
      [ "service" .= sendEventInputService
      , "serviceDisplayName" .= sendEventInputServiceDisplayName
      , "type" .= sendEventInputType
      , "title" .= sendEventInputTitle
      , "body" .= sendEventInputBody
      , "metadata" .= sendEventInputMetadata
      , "externalId" .= sendEventInputExternalId
      , "actionUrl" .= sendEventInputActionUrl
      ]


-- | Construct a value of type 'SendEventInput' (by applying it's required fields, if any)
mkSendEventInput
  :: Text -- ^ 'sendEventInputService' 
  -> Text -- ^ 'sendEventInputType' 
  -> Text -- ^ 'sendEventInputTitle' 
  -> Text -- ^ 'sendEventInputBody' 
  -> SendEventInput
mkSendEventInput sendEventInputService sendEventInputType sendEventInputTitle sendEventInputBody =
  SendEventInput
  { sendEventInputService
  , sendEventInputServiceDisplayName = Nothing
  , sendEventInputType
  , sendEventInputTitle
  , sendEventInputBody
  , sendEventInputMetadata = Nothing
  , sendEventInputExternalId = Nothing
  , sendEventInputActionUrl = Nothing
  }

-- ** Service
-- | Service
data Service = Service
  { serviceId :: !(Text) -- ^ /Required/ "id"
  , serviceName :: !(Text) -- ^ /Required/ "name"
  , serviceDisplayName :: !(Text) -- ^ /Required/ "displayName"
  , serviceCreatedAt :: !(DateTime) -- ^ /Required/ "createdAt"
  , serviceCount :: !(ServiceAllOfCount) -- ^ /Required/ "_count"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON Service
instance A.FromJSON Service where
  parseJSON = A.withObject "Service" $ \o ->
    Service
      <$> (o .:  "id")
      <*> (o .:  "name")
      <*> (o .:  "displayName")
      <*> (o .:  "createdAt")
      <*> (o .:  "_count")

-- | ToJSON Service
instance A.ToJSON Service where
  toJSON Service {..} =
   _omitNulls
      [ "id" .= serviceId
      , "name" .= serviceName
      , "displayName" .= serviceDisplayName
      , "createdAt" .= serviceCreatedAt
      , "_count" .= serviceCount
      ]


-- | Construct a value of type 'Service' (by applying it's required fields, if any)
mkService
  :: Text -- ^ 'serviceId' 
  -> Text -- ^ 'serviceName' 
  -> Text -- ^ 'serviceDisplayName' 
  -> DateTime -- ^ 'serviceCreatedAt' 
  -> ServiceAllOfCount -- ^ 'serviceCount' 
  -> Service
mkService serviceId serviceName serviceDisplayName serviceCreatedAt serviceCount =
  Service
  { serviceId
  , serviceName
  , serviceDisplayName
  , serviceCreatedAt
  , serviceCount
  }

-- ** ServiceAllOfCount
-- | ServiceAllOfCount
data ServiceAllOfCount = ServiceAllOfCount
  { serviceAllOfCountEvents :: !(Int) -- ^ /Required/ "events"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON ServiceAllOfCount
instance A.FromJSON ServiceAllOfCount where
  parseJSON = A.withObject "ServiceAllOfCount" $ \o ->
    ServiceAllOfCount
      <$> (o .:  "events")

-- | ToJSON ServiceAllOfCount
instance A.ToJSON ServiceAllOfCount where
  toJSON ServiceAllOfCount {..} =
   _omitNulls
      [ "events" .= serviceAllOfCountEvents
      ]


-- | Construct a value of type 'ServiceAllOfCount' (by applying it's required fields, if any)
mkServiceAllOfCount
  :: Int -- ^ 'serviceAllOfCountEvents' 
  -> ServiceAllOfCount
mkServiceAllOfCount serviceAllOfCountEvents =
  ServiceAllOfCount
  { serviceAllOfCountEvents
  }

-- ** ServicePreference
-- | ServicePreference
data ServicePreference = ServicePreference
  { servicePreferenceId :: !(Text) -- ^ /Required/ "id"
  , servicePreferenceName :: !(Text) -- ^ /Required/ "name"
  , servicePreferenceDisplayName :: !(Text) -- ^ /Required/ "displayName"
  , servicePreferenceEnabled :: !(Bool) -- ^ /Required/ "enabled"
  , servicePreferenceTypeOverrides :: !([TypeOverride]) -- ^ /Required/ "typeOverrides"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON ServicePreference
instance A.FromJSON ServicePreference where
  parseJSON = A.withObject "ServicePreference" $ \o ->
    ServicePreference
      <$> (o .:  "id")
      <*> (o .:  "name")
      <*> (o .:  "displayName")
      <*> (o .:  "enabled")
      <*> (o .:  "typeOverrides")

-- | ToJSON ServicePreference
instance A.ToJSON ServicePreference where
  toJSON ServicePreference {..} =
   _omitNulls
      [ "id" .= servicePreferenceId
      , "name" .= servicePreferenceName
      , "displayName" .= servicePreferenceDisplayName
      , "enabled" .= servicePreferenceEnabled
      , "typeOverrides" .= servicePreferenceTypeOverrides
      ]


-- | Construct a value of type 'ServicePreference' (by applying it's required fields, if any)
mkServicePreference
  :: Text -- ^ 'servicePreferenceId' 
  -> Text -- ^ 'servicePreferenceName' 
  -> Text -- ^ 'servicePreferenceDisplayName' 
  -> Bool -- ^ 'servicePreferenceEnabled' 
  -> [TypeOverride] -- ^ 'servicePreferenceTypeOverrides' 
  -> ServicePreference
mkServicePreference servicePreferenceId servicePreferenceName servicePreferenceDisplayName servicePreferenceEnabled servicePreferenceTypeOverrides =
  ServicePreference
  { servicePreferenceId
  , servicePreferenceName
  , servicePreferenceDisplayName
  , servicePreferenceEnabled
  , servicePreferenceTypeOverrides
  }

-- ** ServiceSummary
-- | ServiceSummary
data ServiceSummary = ServiceSummary
  { serviceSummaryId :: !(Text) -- ^ /Required/ "id"
  , serviceSummaryName :: !(Text) -- ^ /Required/ "name"
  , serviceSummaryDisplayName :: !(Text) -- ^ /Required/ "displayName"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON ServiceSummary
instance A.FromJSON ServiceSummary where
  parseJSON = A.withObject "ServiceSummary" $ \o ->
    ServiceSummary
      <$> (o .:  "id")
      <*> (o .:  "name")
      <*> (o .:  "displayName")

-- | ToJSON ServiceSummary
instance A.ToJSON ServiceSummary where
  toJSON ServiceSummary {..} =
   _omitNulls
      [ "id" .= serviceSummaryId
      , "name" .= serviceSummaryName
      , "displayName" .= serviceSummaryDisplayName
      ]


-- | Construct a value of type 'ServiceSummary' (by applying it's required fields, if any)
mkServiceSummary
  :: Text -- ^ 'serviceSummaryId' 
  -> Text -- ^ 'serviceSummaryName' 
  -> Text -- ^ 'serviceSummaryDisplayName' 
  -> ServiceSummary
mkServiceSummary serviceSummaryId serviceSummaryName serviceSummaryDisplayName =
  ServiceSummary
  { serviceSummaryId
  , serviceSummaryName
  , serviceSummaryDisplayName
  }

-- ** SetEnabledInput
-- | SetEnabledInput
data SetEnabledInput = SetEnabledInput
  { setEnabledInputEnabled :: !(Bool) -- ^ /Required/ "enabled"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON SetEnabledInput
instance A.FromJSON SetEnabledInput where
  parseJSON = A.withObject "SetEnabledInput" $ \o ->
    SetEnabledInput
      <$> (o .:  "enabled")

-- | ToJSON SetEnabledInput
instance A.ToJSON SetEnabledInput where
  toJSON SetEnabledInput {..} =
   _omitNulls
      [ "enabled" .= setEnabledInputEnabled
      ]


-- | Construct a value of type 'SetEnabledInput' (by applying it's required fields, if any)
mkSetEnabledInput
  :: Bool -- ^ 'setEnabledInputEnabled' 
  -> SetEnabledInput
mkSetEnabledInput setEnabledInputEnabled =
  SetEnabledInput
  { setEnabledInputEnabled
  }

-- ** TextFilterCondition
-- | TextFilterCondition
data TextFilterCondition = TextFilterCondition
  { textFilterConditionField :: !(E'Field2) -- ^ /Required/ "field"
  , textFilterConditionComparison :: !(E'Comparison2) -- ^ /Required/ "comparison"
  , textFilterConditionValue :: !(Text) -- ^ /Required/ "value"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON TextFilterCondition
instance A.FromJSON TextFilterCondition where
  parseJSON = A.withObject "TextFilterCondition" $ \o ->
    TextFilterCondition
      <$> (o .:  "field")
      <*> (o .:  "comparison")
      <*> (o .:  "value")

-- | ToJSON TextFilterCondition
instance A.ToJSON TextFilterCondition where
  toJSON TextFilterCondition {..} =
   _omitNulls
      [ "field" .= textFilterConditionField
      , "comparison" .= textFilterConditionComparison
      , "value" .= textFilterConditionValue
      ]


-- | Construct a value of type 'TextFilterCondition' (by applying it's required fields, if any)
mkTextFilterCondition
  :: E'Field2 -- ^ 'textFilterConditionField' 
  -> E'Comparison2 -- ^ 'textFilterConditionComparison' 
  -> Text -- ^ 'textFilterConditionValue' 
  -> TextFilterCondition
mkTextFilterCondition textFilterConditionField textFilterConditionComparison textFilterConditionValue =
  TextFilterCondition
  { textFilterConditionField
  , textFilterConditionComparison
  , textFilterConditionValue
  }

-- ** TimeFilterCondition
-- | TimeFilterCondition
data TimeFilterCondition = TimeFilterCondition
  { timeFilterConditionField :: !(E'Field) -- ^ /Required/ "field"
  , timeFilterConditionComparison :: !(E'Comparison) -- ^ /Required/ "comparison"
  , timeFilterConditionValue :: !(DateTime) -- ^ /Required/ "value"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON TimeFilterCondition
instance A.FromJSON TimeFilterCondition where
  parseJSON = A.withObject "TimeFilterCondition" $ \o ->
    TimeFilterCondition
      <$> (o .:  "field")
      <*> (o .:  "comparison")
      <*> (o .:  "value")

-- | ToJSON TimeFilterCondition
instance A.ToJSON TimeFilterCondition where
  toJSON TimeFilterCondition {..} =
   _omitNulls
      [ "field" .= timeFilterConditionField
      , "comparison" .= timeFilterConditionComparison
      , "value" .= timeFilterConditionValue
      ]


-- | Construct a value of type 'TimeFilterCondition' (by applying it's required fields, if any)
mkTimeFilterCondition
  :: E'Field -- ^ 'timeFilterConditionField' 
  -> E'Comparison -- ^ 'timeFilterConditionComparison' 
  -> DateTime -- ^ 'timeFilterConditionValue' 
  -> TimeFilterCondition
mkTimeFilterCondition timeFilterConditionField timeFilterConditionComparison timeFilterConditionValue =
  TimeFilterCondition
  { timeFilterConditionField
  , timeFilterConditionComparison
  , timeFilterConditionValue
  }

-- ** TypeOverride
-- | TypeOverride
data TypeOverride = TypeOverride
  { typeOverrideType :: !(Text) -- ^ /Required/ "type"
  , typeOverrideEnabled :: !(Bool) -- ^ /Required/ "enabled"
  , typeOverrideUpdatedAt :: !(DateTime) -- ^ /Required/ "updatedAt"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON TypeOverride
instance A.FromJSON TypeOverride where
  parseJSON = A.withObject "TypeOverride" $ \o ->
    TypeOverride
      <$> (o .:  "type")
      <*> (o .:  "enabled")
      <*> (o .:  "updatedAt")

-- | ToJSON TypeOverride
instance A.ToJSON TypeOverride where
  toJSON TypeOverride {..} =
   _omitNulls
      [ "type" .= typeOverrideType
      , "enabled" .= typeOverrideEnabled
      , "updatedAt" .= typeOverrideUpdatedAt
      ]


-- | Construct a value of type 'TypeOverride' (by applying it's required fields, if any)
mkTypeOverride
  :: Text -- ^ 'typeOverrideType' 
  -> Bool -- ^ 'typeOverrideEnabled' 
  -> DateTime -- ^ 'typeOverrideUpdatedAt' 
  -> TypeOverride
mkTypeOverride typeOverrideType typeOverrideEnabled typeOverrideUpdatedAt =
  TypeOverride
  { typeOverrideType
  , typeOverrideEnabled
  , typeOverrideUpdatedAt
  }

-- ** User
-- | User
data User = User
  { userId :: !(Text) -- ^ /Required/ "id"
  , userEmail :: !(Text) -- ^ /Required/ "email"
  , userDisplayName :: !(Maybe Text) -- ^ "displayName"
  , userHasPassword :: !(Bool) -- ^ /Required/ "hasPassword"
  , userHasGoogle :: !(Bool) -- ^ /Required/ "hasGoogle"
  , userHasApple :: !(Bool) -- ^ /Required/ "hasApple"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON User
instance A.FromJSON User where
  parseJSON = A.withObject "User" $ \o ->
    User
      <$> (o .:  "id")
      <*> (o .:  "email")
      <*> (o .:? "displayName")
      <*> (o .:  "hasPassword")
      <*> (o .:  "hasGoogle")
      <*> (o .:  "hasApple")

-- | ToJSON User
instance A.ToJSON User where
  toJSON User {..} =
   _omitNulls
      [ "id" .= userId
      , "email" .= userEmail
      , "displayName" .= userDisplayName
      , "hasPassword" .= userHasPassword
      , "hasGoogle" .= userHasGoogle
      , "hasApple" .= userHasApple
      ]


-- | Construct a value of type 'User' (by applying it's required fields, if any)
mkUser
  :: Text -- ^ 'userId' 
  -> Text -- ^ 'userEmail' 
  -> Bool -- ^ 'userHasPassword' 
  -> Bool -- ^ 'userHasGoogle' 
  -> Bool -- ^ 'userHasApple' 
  -> User
mkUser userId userEmail userHasPassword userHasGoogle userHasApple =
  User
  { userId
  , userEmail
  , userDisplayName = Nothing
  , userHasPassword
  , userHasGoogle
  , userHasApple
  }

-- ** WebPushConfiguration
-- | WebPushConfiguration
data WebPushConfiguration = WebPushConfiguration
  { webPushConfigurationEnabled :: !(Bool) -- ^ /Required/ "enabled"
  , webPushConfigurationPublicKey :: !(Maybe Text) -- ^ "publicKey"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON WebPushConfiguration
instance A.FromJSON WebPushConfiguration where
  parseJSON = A.withObject "WebPushConfiguration" $ \o ->
    WebPushConfiguration
      <$> (o .:  "enabled")
      <*> (o .:? "publicKey")

-- | ToJSON WebPushConfiguration
instance A.ToJSON WebPushConfiguration where
  toJSON WebPushConfiguration {..} =
   _omitNulls
      [ "enabled" .= webPushConfigurationEnabled
      , "publicKey" .= webPushConfigurationPublicKey
      ]


-- | Construct a value of type 'WebPushConfiguration' (by applying it's required fields, if any)
mkWebPushConfiguration
  :: Bool -- ^ 'webPushConfigurationEnabled' 
  -> WebPushConfiguration
mkWebPushConfiguration webPushConfigurationEnabled =
  WebPushConfiguration
  { webPushConfigurationEnabled
  , webPushConfigurationPublicKey = Nothing
  }

-- ** WebPushSubscription
-- | WebPushSubscription
data WebPushSubscription = WebPushSubscription
  { webPushSubscriptionId :: !(Text) -- ^ /Required/ "id"
  , webPushSubscriptionEnabled :: !(Bool) -- ^ /Required/ "enabled"
  , webPushSubscriptionLastSeenAt :: !(DateTime) -- ^ /Required/ "lastSeenAt"
  } deriving (P.Show, P.Eq, P.Typeable)

-- | FromJSON WebPushSubscription
instance A.FromJSON WebPushSubscription where
  parseJSON = A.withObject "WebPushSubscription" $ \o ->
    WebPushSubscription
      <$> (o .:  "id")
      <*> (o .:  "enabled")
      <*> (o .:  "lastSeenAt")

-- | ToJSON WebPushSubscription
instance A.ToJSON WebPushSubscription where
  toJSON WebPushSubscription {..} =
   _omitNulls
      [ "id" .= webPushSubscriptionId
      , "enabled" .= webPushSubscriptionEnabled
      , "lastSeenAt" .= webPushSubscriptionLastSeenAt
      ]


-- | Construct a value of type 'WebPushSubscription' (by applying it's required fields, if any)
mkWebPushSubscription
  :: Text -- ^ 'webPushSubscriptionId' 
  -> Bool -- ^ 'webPushSubscriptionEnabled' 
  -> DateTime -- ^ 'webPushSubscriptionLastSeenAt' 
  -> WebPushSubscription
mkWebPushSubscription webPushSubscriptionId webPushSubscriptionEnabled webPushSubscriptionLastSeenAt =
  WebPushSubscription
  { webPushSubscriptionId
  , webPushSubscriptionEnabled
  , webPushSubscriptionLastSeenAt
  }


-- * Enums


-- ** E'Comparison

-- | Enum of 'Text'
data E'Comparison
  = E'Comparison'Before -- ^ @"before"@
  | E'Comparison'After -- ^ @"after"@
  | E'Comparison'OnOrBefore -- ^ @"onOrBefore"@
  | E'Comparison'OnOrAfter -- ^ @"onOrAfter"@
  | E'Comparison'Equals -- ^ @"equals"@
  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)

instance A.ToJSON E'Comparison where toJSON = A.toJSON . fromE'Comparison
instance A.FromJSON E'Comparison where parseJSON o = P.either P.fail (pure . P.id) . toE'Comparison =<< A.parseJSON o
instance WH.ToHttpApiData E'Comparison where toQueryParam = WH.toQueryParam . fromE'Comparison
instance WH.FromHttpApiData E'Comparison where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Comparison
instance MimeRender MimeMultipartFormData E'Comparison where mimeRender _ = mimeRenderDefaultMultipartFormData

-- | unwrap 'E'Comparison' enum
fromE'Comparison :: E'Comparison -> Text
fromE'Comparison = \case
  E'Comparison'Before -> "before"
  E'Comparison'After -> "after"
  E'Comparison'OnOrBefore -> "onOrBefore"
  E'Comparison'OnOrAfter -> "onOrAfter"
  E'Comparison'Equals -> "equals"

-- | parse 'E'Comparison' enum
toE'Comparison :: Text -> P.Either String E'Comparison
toE'Comparison = \case
  "before" -> P.Right E'Comparison'Before
  "after" -> P.Right E'Comparison'After
  "onOrBefore" -> P.Right E'Comparison'OnOrBefore
  "onOrAfter" -> P.Right E'Comparison'OnOrAfter
  "equals" -> P.Right E'Comparison'Equals
  s -> P.Left $ "toE'Comparison: enum parse failure: " P.++ P.show s


-- ** E'Comparison2

-- | Enum of 'Text'
data E'Comparison2
  = E'Comparison2'Equals -- ^ @"equals"@
  | E'Comparison2'Contains -- ^ @"contains"@
  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)

instance A.ToJSON E'Comparison2 where toJSON = A.toJSON . fromE'Comparison2
instance A.FromJSON E'Comparison2 where parseJSON o = P.either P.fail (pure . P.id) . toE'Comparison2 =<< A.parseJSON o
instance WH.ToHttpApiData E'Comparison2 where toQueryParam = WH.toQueryParam . fromE'Comparison2
instance WH.FromHttpApiData E'Comparison2 where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Comparison2
instance MimeRender MimeMultipartFormData E'Comparison2 where mimeRender _ = mimeRenderDefaultMultipartFormData

-- | unwrap 'E'Comparison2' enum
fromE'Comparison2 :: E'Comparison2 -> Text
fromE'Comparison2 = \case
  E'Comparison2'Equals -> "equals"
  E'Comparison2'Contains -> "contains"

-- | parse 'E'Comparison2' enum
toE'Comparison2 :: Text -> P.Either String E'Comparison2
toE'Comparison2 = \case
  "equals" -> P.Right E'Comparison2'Equals
  "contains" -> P.Right E'Comparison2'Contains
  s -> P.Left $ "toE'Comparison2: enum parse failure: " P.++ P.show s


-- ** E'Environment

-- | Enum of 'Text'
data E'Environment
  = E'Environment'SANDBOX -- ^ @"SANDBOX"@
  | E'Environment'PRODUCTION -- ^ @"PRODUCTION"@
  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)

instance A.ToJSON E'Environment where toJSON = A.toJSON . fromE'Environment
instance A.FromJSON E'Environment where parseJSON o = P.either P.fail (pure . P.id) . toE'Environment =<< A.parseJSON o
instance WH.ToHttpApiData E'Environment where toQueryParam = WH.toQueryParam . fromE'Environment
instance WH.FromHttpApiData E'Environment where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Environment
instance MimeRender MimeMultipartFormData E'Environment where mimeRender _ = mimeRenderDefaultMultipartFormData

-- | unwrap 'E'Environment' enum
fromE'Environment :: E'Environment -> Text
fromE'Environment = \case
  E'Environment'SANDBOX -> "SANDBOX"
  E'Environment'PRODUCTION -> "PRODUCTION"

-- | parse 'E'Environment' enum
toE'Environment :: Text -> P.Either String E'Environment
toE'Environment = \case
  "SANDBOX" -> P.Right E'Environment'SANDBOX
  "PRODUCTION" -> P.Right E'Environment'PRODUCTION
  s -> P.Left $ "toE'Environment: enum parse failure: " P.++ P.show s


-- ** E'Field

-- | Enum of 'Text'
data E'Field
  = E'Field'CreatedAt -- ^ @"createdAt"@
  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)

instance A.ToJSON E'Field where toJSON = A.toJSON . fromE'Field
instance A.FromJSON E'Field where parseJSON o = P.either P.fail (pure . P.id) . toE'Field =<< A.parseJSON o
instance WH.ToHttpApiData E'Field where toQueryParam = WH.toQueryParam . fromE'Field
instance WH.FromHttpApiData E'Field where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Field
instance MimeRender MimeMultipartFormData E'Field where mimeRender _ = mimeRenderDefaultMultipartFormData

-- | unwrap 'E'Field' enum
fromE'Field :: E'Field -> Text
fromE'Field = \case
  E'Field'CreatedAt -> "createdAt"

-- | parse 'E'Field' enum
toE'Field :: Text -> P.Either String E'Field
toE'Field = \case
  "createdAt" -> P.Right E'Field'CreatedAt
  s -> P.Left $ "toE'Field: enum parse failure: " P.++ P.show s


-- ** E'Field2

-- | Enum of 'Text'
data E'Field2
  = E'Field2'Service -- ^ @"service"@
  | E'Field2'Type -- ^ @"type"@
  | E'Field2'Title -- ^ @"title"@
  | E'Field2'Body -- ^ @"body"@
  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)

instance A.ToJSON E'Field2 where toJSON = A.toJSON . fromE'Field2
instance A.FromJSON E'Field2 where parseJSON o = P.either P.fail (pure . P.id) . toE'Field2 =<< A.parseJSON o
instance WH.ToHttpApiData E'Field2 where toQueryParam = WH.toQueryParam . fromE'Field2
instance WH.FromHttpApiData E'Field2 where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Field2
instance MimeRender MimeMultipartFormData E'Field2 where mimeRender _ = mimeRenderDefaultMultipartFormData

-- | unwrap 'E'Field2' enum
fromE'Field2 :: E'Field2 -> Text
fromE'Field2 = \case
  E'Field2'Service -> "service"
  E'Field2'Type -> "type"
  E'Field2'Title -> "title"
  E'Field2'Body -> "body"

-- | parse 'E'Field2' enum
toE'Field2 :: Text -> P.Either String E'Field2
toE'Field2 = \case
  "service" -> P.Right E'Field2'Service
  "type" -> P.Right E'Field2'Type
  "title" -> P.Right E'Field2'Title
  "body" -> P.Right E'Field2'Body
  s -> P.Left $ "toE'Field2: enum parse failure: " P.++ P.show s


-- ** E'Operator

-- | Enum of 'Text'
data E'Operator
  = E'Operator'NOT -- ^ @"NOT"@
  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)

instance A.ToJSON E'Operator where toJSON = A.toJSON . fromE'Operator
instance A.FromJSON E'Operator where parseJSON o = P.either P.fail (pure . P.id) . toE'Operator =<< A.parseJSON o
instance WH.ToHttpApiData E'Operator where toQueryParam = WH.toQueryParam . fromE'Operator
instance WH.FromHttpApiData E'Operator where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Operator
instance MimeRender MimeMultipartFormData E'Operator where mimeRender _ = mimeRenderDefaultMultipartFormData

-- | unwrap 'E'Operator' enum
fromE'Operator :: E'Operator -> Text
fromE'Operator = \case
  E'Operator'NOT -> "NOT"

-- | parse 'E'Operator' enum
toE'Operator :: Text -> P.Either String E'Operator
toE'Operator = \case
  "NOT" -> P.Right E'Operator'NOT
  s -> P.Left $ "toE'Operator: enum parse failure: " P.++ P.show s


-- ** E'Operator2

-- | Enum of 'Text'
data E'Operator2
  = E'Operator2'AND -- ^ @"AND"@
  | E'Operator2'OR -- ^ @"OR"@
  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)

instance A.ToJSON E'Operator2 where toJSON = A.toJSON . fromE'Operator2
instance A.FromJSON E'Operator2 where parseJSON o = P.either P.fail (pure . P.id) . toE'Operator2 =<< A.parseJSON o
instance WH.ToHttpApiData E'Operator2 where toQueryParam = WH.toQueryParam . fromE'Operator2
instance WH.FromHttpApiData E'Operator2 where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Operator2
instance MimeRender MimeMultipartFormData E'Operator2 where mimeRender _ = mimeRenderDefaultMultipartFormData

-- | unwrap 'E'Operator2' enum
fromE'Operator2 :: E'Operator2 -> Text
fromE'Operator2 = \case
  E'Operator2'AND -> "AND"
  E'Operator2'OR -> "OR"

-- | parse 'E'Operator2' enum
toE'Operator2 :: Text -> P.Either String E'Operator2
toE'Operator2 = \case
  "AND" -> P.Right E'Operator2'AND
  "OR" -> P.Right E'Operator2'OR
  s -> P.Left $ "toE'Operator2: enum parse failure: " P.++ P.show s


-- ** E'Role

-- | Enum of 'Text'
data E'Role
  = E'Role'OWNER -- ^ @"OWNER"@
  | E'Role'MEMBER -- ^ @"MEMBER"@
  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)

instance A.ToJSON E'Role where toJSON = A.toJSON . fromE'Role
instance A.FromJSON E'Role where parseJSON o = P.either P.fail (pure . P.id) . toE'Role =<< A.parseJSON o
instance WH.ToHttpApiData E'Role where toQueryParam = WH.toQueryParam . fromE'Role
instance WH.FromHttpApiData E'Role where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Role
instance MimeRender MimeMultipartFormData E'Role where mimeRender _ = mimeRenderDefaultMultipartFormData

-- | unwrap 'E'Role' enum
fromE'Role :: E'Role -> Text
fromE'Role = \case
  E'Role'OWNER -> "OWNER"
  E'Role'MEMBER -> "MEMBER"

-- | parse 'E'Role' enum
toE'Role :: Text -> P.Either String E'Role
toE'Role = \case
  "OWNER" -> P.Right E'Role'OWNER
  "MEMBER" -> P.Right E'Role'MEMBER
  s -> P.Left $ "toE'Role: enum parse failure: " P.++ P.show s


-- ** E'Service

-- | Enum of 'Text'
data E'Service
  = E'Service'Agent_push_kit -- ^ @"agent-push-kit"@
  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)

instance A.ToJSON E'Service where toJSON = A.toJSON . fromE'Service
instance A.FromJSON E'Service where parseJSON o = P.either P.fail (pure . P.id) . toE'Service =<< A.parseJSON o
instance WH.ToHttpApiData E'Service where toQueryParam = WH.toQueryParam . fromE'Service
instance WH.FromHttpApiData E'Service where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Service
instance MimeRender MimeMultipartFormData E'Service where mimeRender _ = mimeRenderDefaultMultipartFormData

-- | unwrap 'E'Service' enum
fromE'Service :: E'Service -> Text
fromE'Service = \case
  E'Service'Agent_push_kit -> "agent-push-kit"

-- | parse 'E'Service' enum
toE'Service :: Text -> P.Either String E'Service
toE'Service = \case
  "agent-push-kit" -> P.Right E'Service'Agent_push_kit
  s -> P.Left $ "toE'Service: enum parse failure: " P.++ P.show s


-- ** E'Status

-- | Enum of 'Text'
data E'Status
  = E'Status'Ok -- ^ @"ok"@
  deriving (P.Show, P.Eq, P.Typeable, P.Ord, P.Bounded, P.Enum)

instance A.ToJSON E'Status where toJSON = A.toJSON . fromE'Status
instance A.FromJSON E'Status where parseJSON o = P.either P.fail (pure . P.id) . toE'Status =<< A.parseJSON o
instance WH.ToHttpApiData E'Status where toQueryParam = WH.toQueryParam . fromE'Status
instance WH.FromHttpApiData E'Status where parseQueryParam o = WH.parseQueryParam o >>= P.left T.pack . toE'Status
instance MimeRender MimeMultipartFormData E'Status where mimeRender _ = mimeRenderDefaultMultipartFormData

-- | unwrap 'E'Status' enum
fromE'Status :: E'Status -> Text
fromE'Status = \case
  E'Status'Ok -> "ok"

-- | parse 'E'Status' enum
toE'Status :: Text -> P.Either String E'Status
toE'Status = \case
  "ok" -> P.Right E'Status'Ok
  s -> P.Left $ "toE'Status: enum parse failure: " P.++ P.show s


-- * Auth Methods