{-
   Neptune Backend API

   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

   OpenAPI Version: 3.0.1
   Neptune Backend API API version: 2.8
   Generated by OpenAPI Generator (https://openapi-generator.tech)
-}

{-|
Module : Neptune.Backend.API.ApiDefault
-}

{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MonoLocalBinds        #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings     #-}
{-# OPTIONS_GHC -fno-warn-name-shadowing -fno-warn-unused-binds -fno-warn-unused-imports #-}

module Neptune.Backend.API.ApiDefault where

import           Neptune.Backend.Core
import           Neptune.Backend.MimeTypes
import           Neptune.Backend.Model                 as M

import qualified Data.Aeson                            as A
import qualified Data.ByteString                       as B
import qualified Data.ByteString.Lazy                  as BL
import qualified Data.Data                             as P (TypeRep, Typeable,
                                                             typeOf, typeRep)
import qualified Data.Foldable                         as P
import qualified Data.Map                              as Map
import qualified Data.Maybe                            as P
import qualified Data.Proxy                            as P (Proxy (..))
import qualified Data.Set                              as Set
import qualified Data.String                           as P
import qualified Data.Text                             as T
import qualified Data.Text.Encoding                    as T
import qualified Data.Text.Lazy                        as TL
import qualified Data.Text.Lazy.Encoding               as TL
import qualified Data.Time                             as TI
import qualified Network.HTTP.Client.MultipartFormData as NH
import qualified Network.HTTP.Media                    as ME
import qualified Network.HTTP.Types                    as NH
import qualified Web.FormUrlEncoded                    as WH
import qualified Web.HttpApiData                       as WH

import           Data.Text                             (Text)
import           GHC.Base                              ((<|>))

import           Prelude                               (Applicative, Bool (..),
                                                        Char, Double, FilePath,
                                                        Float, Functor, Int,
                                                        Integer, Maybe (..),
                                                        Monad, String, fmap,
                                                        maybe, mempty, pure,
                                                        undefined, ($), (.),
                                                        (/=), (<$>), (<*>),
                                                        (==), (>>=))
import qualified Prelude                               as P

-- * Operations


-- ** Default

-- *** abortExperiments

-- | @POST \/api\/leaderboard\/v1\/experiments\/abort@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
abortExperiments
  :: (Consumes AbortExperiments contentType, MimeRender contentType ExperimentIds)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ExperimentIds -- ^ "experimentIds"
  -> NeptuneBackendRequest AbortExperiments contentType [BatchExperimentUpdateResult] accept
abortExperiments :: ContentType contentType
-> Accept accept
-> ExperimentIds
-> NeptuneBackendRequest
     AbortExperiments contentType [BatchExperimentUpdateResult] accept
abortExperiments ContentType contentType
_  Accept accept
_ ExperimentIds
experimentIds =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     AbortExperiments contentType [BatchExperimentUpdateResult] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/experiments/abort"]
    NeptuneBackendRequest
  AbortExperiments contentType [BatchExperimentUpdateResult] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     AbortExperiments contentType [BatchExperimentUpdateResult] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  AbortExperiments contentType [BatchExperimentUpdateResult] accept
-> ExperimentIds
-> NeptuneBackendRequest
     AbortExperiments contentType [BatchExperimentUpdateResult] accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ExperimentIds
experimentIds

data AbortExperiments
instance HasBodyParam AbortExperiments ExperimentIds
instance HasOptionalParam AbortExperiments MarkOnly where
  applyOptionalParam :: NeptuneBackendRequest AbortExperiments contentType res accept
-> MarkOnly
-> NeptuneBackendRequest AbortExperiments contentType res accept
applyOptionalParam NeptuneBackendRequest AbortExperiments contentType res accept
req (MarkOnly Bool
xs) =
    NeptuneBackendRequest AbortExperiments contentType res accept
req NeptuneBackendRequest AbortExperiments contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest AbortExperiments contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Bool) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"markOnly", Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
xs)

-- | @*/*@
instance MimeType mtype => Consumes AbortExperiments mtype

-- | @*/*@
instance MimeType mtype => Produces AbortExperiments mtype


-- *** acceptOrganizationInvitation

-- | @POST \/api\/backend\/v1\/invitations\/organization\/{invitationId}\/accept@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
acceptOrganizationInvitation
  :: Accept accept -- ^ request accept ('MimeType')
  -> InvitationId -- ^ "invitationId"
  -> NeptuneBackendRequest AcceptOrganizationInvitation MimeNoContent res accept
acceptOrganizationInvitation :: Accept accept
-> InvitationId
-> NeptuneBackendRequest
     AcceptOrganizationInvitation MimeNoContent res accept
acceptOrganizationInvitation  Accept accept
_ (InvitationId Text
invitationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     AcceptOrganizationInvitation MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/invitations/organization/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
invitationId,ByteString
"/accept"]
    NeptuneBackendRequest
  AcceptOrganizationInvitation MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     AcceptOrganizationInvitation MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data AcceptOrganizationInvitation
-- | @*/*@
instance MimeType mtype => Produces AcceptOrganizationInvitation mtype


-- *** acceptProjectInvitation

-- | @POST \/api\/backend\/v1\/invitations\/project\/{invitationId}\/accept@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
acceptProjectInvitation
  :: Accept accept -- ^ request accept ('MimeType')
  -> InvitationId -- ^ "invitationId"
  -> NeptuneBackendRequest AcceptProjectInvitation MimeNoContent res accept
acceptProjectInvitation :: Accept accept
-> InvitationId
-> NeptuneBackendRequest
     AcceptProjectInvitation MimeNoContent res accept
acceptProjectInvitation  Accept accept
_ (InvitationId Text
invitationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     AcceptProjectInvitation MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/invitations/project/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
invitationId,ByteString
"/accept"]
    NeptuneBackendRequest
  AcceptProjectInvitation MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     AcceptProjectInvitation MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data AcceptProjectInvitation
-- | @*/*@
instance MimeType mtype => Produces AcceptProjectInvitation mtype


-- *** addOrganizationMember

-- | @POST \/api\/backend\/v1\/organizations2\/{organizationIdentifier}\/members@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
addOrganizationMember
  :: (Consumes AddOrganizationMember contentType, MimeRender contentType NewOrganizationMemberDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> NewOrganizationMemberDTO -- ^ "member"
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> NeptuneBackendRequest AddOrganizationMember contentType OrganizationMemberDTO accept
addOrganizationMember :: ContentType contentType
-> Accept accept
-> NewOrganizationMemberDTO
-> OrganizationIdentifier
-> NeptuneBackendRequest
     AddOrganizationMember contentType OrganizationMemberDTO accept
addOrganizationMember ContentType contentType
_  Accept accept
_ NewOrganizationMemberDTO
member (OrganizationIdentifier Text
organizationIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     AddOrganizationMember contentType OrganizationMemberDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/members"]
    NeptuneBackendRequest
  AddOrganizationMember contentType OrganizationMemberDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     AddOrganizationMember contentType OrganizationMemberDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  AddOrganizationMember contentType OrganizationMemberDTO accept
-> NewOrganizationMemberDTO
-> NeptuneBackendRequest
     AddOrganizationMember contentType OrganizationMemberDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` NewOrganizationMemberDTO
member

data AddOrganizationMember
instance HasBodyParam AddOrganizationMember NewOrganizationMemberDTO

-- | @*/*@
instance MimeType mtype => Consumes AddOrganizationMember mtype

-- | @*/*@
instance MimeType mtype => Produces AddOrganizationMember mtype


-- *** addProjectMember

-- | @POST \/api\/backend\/v1\/projects\/members@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
addProjectMember
  :: (Consumes AddProjectMember contentType, MimeRender contentType NewProjectMemberDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> NewProjectMemberDTO -- ^ "member"
  -> ProjectIdentifier -- ^ "projectIdentifier"
  -> NeptuneBackendRequest AddProjectMember contentType ProjectMemberDTO accept
addProjectMember :: ContentType contentType
-> Accept accept
-> NewProjectMemberDTO
-> ProjectIdentifier
-> NeptuneBackendRequest
     AddProjectMember contentType ProjectMemberDTO accept
addProjectMember ContentType contentType
_  Accept accept
_ NewProjectMemberDTO
member (ProjectIdentifier Text
projectIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     AddProjectMember contentType ProjectMemberDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/projects/members"]
    NeptuneBackendRequest
  AddProjectMember contentType ProjectMemberDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     AddProjectMember contentType ProjectMemberDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  AddProjectMember contentType ProjectMemberDTO accept
-> NewProjectMemberDTO
-> NeptuneBackendRequest
     AddProjectMember contentType ProjectMemberDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` NewProjectMemberDTO
member
    NeptuneBackendRequest
  AddProjectMember contentType ProjectMemberDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     AddProjectMember contentType ProjectMemberDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectIdentifier)

data AddProjectMember
instance HasBodyParam AddProjectMember NewProjectMemberDTO

-- | @*/*@
instance MimeType mtype => Consumes AddProjectMember mtype

-- | @*/*@
instance MimeType mtype => Produces AddProjectMember mtype


-- *** addUserProfileLink

-- | @POST \/api\/backend\/v1\/userProfile\/links@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
addUserProfileLink
  :: (Consumes AddUserProfileLink contentType, MimeRender contentType UserProfileLinkDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> UserProfileLinkDTO -- ^ "link"
  -> NeptuneBackendRequest AddUserProfileLink contentType res accept
addUserProfileLink :: ContentType contentType
-> Accept accept
-> UserProfileLinkDTO
-> NeptuneBackendRequest AddUserProfileLink contentType res accept
addUserProfileLink ContentType contentType
_  Accept accept
_ UserProfileLinkDTO
link =
  Method
-> [ByteString]
-> NeptuneBackendRequest AddUserProfileLink contentType res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/userProfile/links"]
    NeptuneBackendRequest AddUserProfileLink contentType res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest AddUserProfileLink contentType res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest AddUserProfileLink contentType res accept
-> UserProfileLinkDTO
-> NeptuneBackendRequest AddUserProfileLink contentType res accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` UserProfileLinkDTO
link

data AddUserProfileLink
instance HasBodyParam AddUserProfileLink UserProfileLinkDTO

-- | @*/*@
instance MimeType mtype => Consumes AddUserProfileLink mtype

-- | @*/*@
instance MimeType mtype => Produces AddUserProfileLink mtype


-- *** authorize

-- | @GET \/api\/backend\/v1\/authorization\/authorize@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
authorize
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest Authorize MimeNoContent AuthorizedUserDTO accept
authorize :: Accept accept
-> NeptuneBackendRequest
     Authorize MimeNoContent AuthorizedUserDTO accept
authorize  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     Authorize MimeNoContent AuthorizedUserDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/authorization/authorize"]
    NeptuneBackendRequest
  Authorize MimeNoContent AuthorizedUserDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     Authorize MimeNoContent AuthorizedUserDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data Authorize
-- | @*/*@
instance MimeType mtype => Produces Authorize mtype


-- *** cancelSubscription

-- | @POST \/api\/backend\/v1\/organizations2\/{organizationId}\/cancelSubscription@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
cancelSubscription
  :: (Consumes CancelSubscription contentType, MimeRender contentType SubscriptionCancelInfoDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> SubscriptionCancelInfoDTO -- ^ "subscriptionCancel"
  -> OrganizationId -- ^ "organizationId"
  -> NeptuneBackendRequest CancelSubscription contentType res accept
cancelSubscription :: ContentType contentType
-> Accept accept
-> SubscriptionCancelInfoDTO
-> OrganizationId
-> NeptuneBackendRequest CancelSubscription contentType res accept
cancelSubscription ContentType contentType
_  Accept accept
_ SubscriptionCancelInfoDTO
subscriptionCancel (OrganizationId Text
organizationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest CancelSubscription contentType res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationId,ByteString
"/cancelSubscription"]
    NeptuneBackendRequest CancelSubscription contentType res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest CancelSubscription contentType res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest CancelSubscription contentType res accept
-> SubscriptionCancelInfoDTO
-> NeptuneBackendRequest CancelSubscription contentType res accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` SubscriptionCancelInfoDTO
subscriptionCancel

data CancelSubscription
instance HasBodyParam CancelSubscription SubscriptionCancelInfoDTO

-- | @*/*@
instance MimeType mtype => Consumes CancelSubscription mtype

-- | @*/*@
instance MimeType mtype => Produces CancelSubscription mtype


-- *** changePassword

-- | @PUT \/api\/backend\/v1\/userProfile\/password@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
changePassword
  :: (Consumes ChangePassword contentType, MimeRender contentType PasswordChangeDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> PasswordChangeDTO -- ^ "passwordToUpdate"
  -> NeptuneBackendRequest ChangePassword contentType PasswordChangeDTO accept
changePassword :: ContentType contentType
-> Accept accept
-> PasswordChangeDTO
-> NeptuneBackendRequest
     ChangePassword contentType PasswordChangeDTO accept
changePassword ContentType contentType
_  Accept accept
_ PasswordChangeDTO
passwordToUpdate =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ChangePassword contentType PasswordChangeDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/userProfile/password"]
    NeptuneBackendRequest
  ChangePassword contentType PasswordChangeDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     ChangePassword contentType PasswordChangeDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  ChangePassword contentType PasswordChangeDTO accept
-> PasswordChangeDTO
-> NeptuneBackendRequest
     ChangePassword contentType PasswordChangeDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` PasswordChangeDTO
passwordToUpdate

data ChangePassword
instance HasBodyParam ChangePassword PasswordChangeDTO

-- | @*/*@
instance MimeType mtype => Consumes ChangePassword mtype

-- | @*/*@
instance MimeType mtype => Produces ChangePassword mtype


-- *** configInfoGet

-- | @GET \/api\/backend\/v1\/configInfo@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
configInfoGet
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest ConfigInfoGet MimeNoContent ConfigInfo accept
configInfoGet :: Accept accept
-> NeptuneBackendRequest
     ConfigInfoGet MimeNoContent ConfigInfo accept
configInfoGet  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ConfigInfoGet MimeNoContent ConfigInfo accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/configInfo"]
    NeptuneBackendRequest ConfigInfoGet MimeNoContent ConfigInfo accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     ConfigInfoGet MimeNoContent ConfigInfo accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data ConfigInfoGet
-- | @*/*@
instance MimeType mtype => Produces ConfigInfoGet mtype


-- *** createCardUpdateSession

-- | @POST \/api\/backend\/v1\/payments\/{organizationIdentifier}\/creditCard@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createCardUpdateSession
  :: (Consumes CreateCardUpdateSession contentType, MimeRender contentType CreateSessionParamsDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> CreateSessionParamsDTO -- ^ "createSessionParams" -  Stripe Checkout Session details
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> NeptuneBackendRequest CreateCardUpdateSession contentType SessionDTO accept
createCardUpdateSession :: ContentType contentType
-> Accept accept
-> CreateSessionParamsDTO
-> OrganizationIdentifier
-> NeptuneBackendRequest
     CreateCardUpdateSession contentType SessionDTO accept
createCardUpdateSession ContentType contentType
_  Accept accept
_ CreateSessionParamsDTO
createSessionParams (OrganizationIdentifier Text
organizationIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     CreateCardUpdateSession contentType SessionDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/payments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/creditCard"]
    NeptuneBackendRequest
  CreateCardUpdateSession contentType SessionDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     CreateCardUpdateSession contentType SessionDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  CreateCardUpdateSession contentType SessionDTO accept
-> CreateSessionParamsDTO
-> NeptuneBackendRequest
     CreateCardUpdateSession contentType SessionDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` CreateSessionParamsDTO
createSessionParams

data CreateCardUpdateSession

-- | /Body Param/ "createSessionParams" - Stripe Checkout Session details
instance HasBodyParam CreateCardUpdateSession CreateSessionParamsDTO

-- | @*/*@
instance MimeType mtype => Consumes CreateCardUpdateSession mtype

-- | @*/*@
instance MimeType mtype => Produces CreateCardUpdateSession mtype


-- *** createChannel

-- | @POST \/api\/leaderboard\/v1\/channels\/user@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createChannel
  :: (Consumes CreateChannel contentType, MimeRender contentType ChannelParams)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ChannelParams -- ^ "channelToCreate"
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest CreateChannel contentType ChannelDTO accept
createChannel :: ContentType contentType
-> Accept accept
-> ChannelParams
-> ExperimentId
-> NeptuneBackendRequest
     CreateChannel contentType ChannelDTO accept
createChannel ContentType contentType
_  Accept accept
_ ChannelParams
channelToCreate (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     CreateChannel contentType ChannelDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/channels/user"]
    NeptuneBackendRequest CreateChannel contentType ChannelDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     CreateChannel contentType ChannelDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest CreateChannel contentType ChannelDTO accept
-> ChannelParams
-> NeptuneBackendRequest
     CreateChannel contentType ChannelDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ChannelParams
channelToCreate
    NeptuneBackendRequest CreateChannel contentType ChannelDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     CreateChannel contentType ChannelDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
experimentId)

data CreateChannel
instance HasBodyParam CreateChannel ChannelParams

-- | @*/*@
instance MimeType mtype => Consumes CreateChannel mtype

-- | @*/*@
instance MimeType mtype => Produces CreateChannel mtype


-- *** createChart

-- | @POST \/api\/backend\/v1\/chartSets\/{chartSetId}\/charts@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createChart
  :: (Consumes CreateChart contentType, MimeRender contentType ChartDefinition)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ChartDefinition -- ^ "chartToCreate"
  -> ChartSetId -- ^ "chartSetId"
  -> NeptuneBackendRequest CreateChart contentType Chart accept
createChart :: ContentType contentType
-> Accept accept
-> ChartDefinition
-> ChartSetId
-> NeptuneBackendRequest CreateChart contentType Chart accept
createChart ContentType contentType
_  Accept accept
_ ChartDefinition
chartToCreate (ChartSetId Text
chartSetId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest CreateChart contentType Chart accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/chartSets/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
chartSetId,ByteString
"/charts"]
    NeptuneBackendRequest CreateChart contentType Chart accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest CreateChart contentType Chart accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest CreateChart contentType Chart accept
-> ChartDefinition
-> NeptuneBackendRequest CreateChart contentType Chart accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ChartDefinition
chartToCreate

data CreateChart
instance HasBodyParam CreateChart ChartDefinition

-- | @*/*@
instance MimeType mtype => Consumes CreateChart mtype

-- | @*/*@
instance MimeType mtype => Produces CreateChart mtype


-- *** createChartSet

-- | @POST \/api\/backend\/v1\/chartSets@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createChartSet
  :: (Consumes CreateChartSet contentType, MimeRender contentType ChartSetParams)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ChartSetParams -- ^ "chartSetToCreate"
  -> ProjectId -- ^ "projectId"
  -> NeptuneBackendRequest CreateChartSet contentType ChartSet accept
createChartSet :: ContentType contentType
-> Accept accept
-> ChartSetParams
-> ProjectId
-> NeptuneBackendRequest CreateChartSet contentType ChartSet accept
createChartSet ContentType contentType
_  Accept accept
_ ChartSetParams
chartSetToCreate (ProjectId Text
projectId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest CreateChartSet contentType ChartSet accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/chartSets"]
    NeptuneBackendRequest CreateChartSet contentType ChartSet accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest CreateChartSet contentType ChartSet accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest CreateChartSet contentType ChartSet accept
-> ChartSetParams
-> NeptuneBackendRequest CreateChartSet contentType ChartSet accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ChartSetParams
chartSetToCreate
    NeptuneBackendRequest CreateChartSet contentType ChartSet accept
-> [QueryItem]
-> NeptuneBackendRequest CreateChartSet contentType ChartSet accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectId)

data CreateChartSet
instance HasBodyParam CreateChartSet ChartSetParams

-- | @*/*@
instance MimeType mtype => Consumes CreateChartSet mtype

-- | @*/*@
instance MimeType mtype => Produces CreateChartSet mtype


-- *** createCheckoutSession

-- | @POST \/api\/backend\/v1\/payments\/{organizationIdentifier}\/session@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createCheckoutSession
  :: (Consumes CreateCheckoutSession contentType, MimeRender contentType CreateSessionParamsDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> CreateSessionParamsDTO -- ^ "createSessionParams" -  Stripe Checkout Session details
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> NeptuneBackendRequest CreateCheckoutSession contentType SessionDTO accept
createCheckoutSession :: ContentType contentType
-> Accept accept
-> CreateSessionParamsDTO
-> OrganizationIdentifier
-> NeptuneBackendRequest
     CreateCheckoutSession contentType SessionDTO accept
createCheckoutSession ContentType contentType
_  Accept accept
_ CreateSessionParamsDTO
createSessionParams (OrganizationIdentifier Text
organizationIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     CreateCheckoutSession contentType SessionDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/payments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/session"]
    NeptuneBackendRequest
  CreateCheckoutSession contentType SessionDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     CreateCheckoutSession contentType SessionDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  CreateCheckoutSession contentType SessionDTO accept
-> CreateSessionParamsDTO
-> NeptuneBackendRequest
     CreateCheckoutSession contentType SessionDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` CreateSessionParamsDTO
createSessionParams

data CreateCheckoutSession

-- | /Body Param/ "createSessionParams" - Stripe Checkout Session details
instance HasBodyParam CreateCheckoutSession CreateSessionParamsDTO

-- | @*/*@
instance MimeType mtype => Consumes CreateCheckoutSession mtype

-- | @*/*@
instance MimeType mtype => Produces CreateCheckoutSession mtype


-- *** createExperiment

-- | @POST \/api\/leaderboard\/v1\/experiments@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createExperiment
  :: (Consumes CreateExperiment contentType, MimeRender contentType ExperimentCreationParams)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ExperimentCreationParams -- ^ "experimentCreationParams"
  -> NeptuneBackendRequest CreateExperiment contentType Experiment accept
createExperiment :: ContentType contentType
-> Accept accept
-> ExperimentCreationParams
-> NeptuneBackendRequest
     CreateExperiment contentType Experiment accept
createExperiment ContentType contentType
_  Accept accept
_ ExperimentCreationParams
experimentCreationParams =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     CreateExperiment contentType Experiment accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/experiments"]
    NeptuneBackendRequest
  CreateExperiment contentType Experiment accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     CreateExperiment contentType Experiment accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  CreateExperiment contentType Experiment accept
-> ExperimentCreationParams
-> NeptuneBackendRequest
     CreateExperiment contentType Experiment accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ExperimentCreationParams
experimentCreationParams

data CreateExperiment
instance HasBodyParam CreateExperiment ExperimentCreationParams
instance HasOptionalParam CreateExperiment XNeptuneCliVersion where
  applyOptionalParam :: NeptuneBackendRequest CreateExperiment contentType res accept
-> XNeptuneCliVersion
-> NeptuneBackendRequest CreateExperiment contentType res accept
applyOptionalParam NeptuneBackendRequest CreateExperiment contentType res accept
req (XNeptuneCliVersion Text
xs) =
    NeptuneBackendRequest CreateExperiment contentType res accept
req NeptuneBackendRequest CreateExperiment contentType res accept
-> [Header]
-> NeptuneBackendRequest CreateExperiment contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [Header] -> NeptuneBackendRequest req contentType res accept
`addHeader` (HeaderName, Text) -> [Header]
forall a. ToHttpApiData a => (HeaderName, a) -> [Header]
toHeader (HeaderName
"X-Neptune-CliVersion", Text
xs)

-- | @*/*@
instance MimeType mtype => Consumes CreateExperiment mtype

-- | @*/*@
instance MimeType mtype => Produces CreateExperiment mtype


-- *** createOrganization

-- | @POST \/api\/backend\/v1\/organizations2@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createOrganization
  :: (Consumes CreateOrganization contentType, MimeRender contentType OrganizationCreationParamsDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> OrganizationCreationParamsDTO -- ^ "organizationToCreate"
  -> NeptuneBackendRequest CreateOrganization contentType OrganizationDTO accept
createOrganization :: ContentType contentType
-> Accept accept
-> OrganizationCreationParamsDTO
-> NeptuneBackendRequest
     CreateOrganization contentType OrganizationDTO accept
createOrganization ContentType contentType
_  Accept accept
_ OrganizationCreationParamsDTO
organizationToCreate =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     CreateOrganization contentType OrganizationDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/organizations2"]
    NeptuneBackendRequest
  CreateOrganization contentType OrganizationDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     CreateOrganization contentType OrganizationDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  CreateOrganization contentType OrganizationDTO accept
-> OrganizationCreationParamsDTO
-> NeptuneBackendRequest
     CreateOrganization contentType OrganizationDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` OrganizationCreationParamsDTO
organizationToCreate

data CreateOrganization
instance HasBodyParam CreateOrganization OrganizationCreationParamsDTO

-- | @*/*@
instance MimeType mtype => Consumes CreateOrganization mtype

-- | @*/*@
instance MimeType mtype => Produces CreateOrganization mtype


-- *** createOrganizationInvitation

-- | @POST \/api\/backend\/v1\/invitations\/organization@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createOrganizationInvitation
  :: (Consumes CreateOrganizationInvitation contentType, MimeRender contentType NewOrganizationInvitationDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> NewOrganizationInvitationDTO -- ^ "newOrganizationInvitation" -  addToAllProjects flag is ignored when roleGrant value is admin
  -> NeptuneBackendRequest CreateOrganizationInvitation contentType OrganizationInvitationDTO accept
createOrganizationInvitation :: ContentType contentType
-> Accept accept
-> NewOrganizationInvitationDTO
-> NeptuneBackendRequest
     CreateOrganizationInvitation
     contentType
     OrganizationInvitationDTO
     accept
createOrganizationInvitation ContentType contentType
_  Accept accept
_ NewOrganizationInvitationDTO
newOrganizationInvitation =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     CreateOrganizationInvitation
     contentType
     OrganizationInvitationDTO
     accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/invitations/organization"]
    NeptuneBackendRequest
  CreateOrganizationInvitation
  contentType
  OrganizationInvitationDTO
  accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     CreateOrganizationInvitation
     contentType
     OrganizationInvitationDTO
     accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  CreateOrganizationInvitation
  contentType
  OrganizationInvitationDTO
  accept
-> NewOrganizationInvitationDTO
-> NeptuneBackendRequest
     CreateOrganizationInvitation
     contentType
     OrganizationInvitationDTO
     accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` NewOrganizationInvitationDTO
newOrganizationInvitation

data CreateOrganizationInvitation

-- | /Body Param/ "newOrganizationInvitation" - addToAllProjects flag is ignored when roleGrant value is admin
instance HasBodyParam CreateOrganizationInvitation NewOrganizationInvitationDTO

-- | @*/*@
instance MimeType mtype => Consumes CreateOrganizationInvitation mtype

-- | @*/*@
instance MimeType mtype => Produces CreateOrganizationInvitation mtype


-- *** createProject

-- | @POST \/api\/backend\/v1\/projects@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createProject
  :: (Consumes CreateProject contentType, MimeRender contentType NewProjectDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> NewProjectDTO -- ^ "projectToCreate"
  -> NeptuneBackendRequest CreateProject contentType ProjectWithRoleDTO accept
createProject :: ContentType contentType
-> Accept accept
-> NewProjectDTO
-> NeptuneBackendRequest
     CreateProject contentType ProjectWithRoleDTO accept
createProject ContentType contentType
_  Accept accept
_ NewProjectDTO
projectToCreate =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     CreateProject contentType ProjectWithRoleDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/projects"]
    NeptuneBackendRequest
  CreateProject contentType ProjectWithRoleDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     CreateProject contentType ProjectWithRoleDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  CreateProject contentType ProjectWithRoleDTO accept
-> NewProjectDTO
-> NeptuneBackendRequest
     CreateProject contentType ProjectWithRoleDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` NewProjectDTO
projectToCreate

data CreateProject
instance HasBodyParam CreateProject NewProjectDTO

-- | @*/*@
instance MimeType mtype => Consumes CreateProject mtype

-- | @*/*@
instance MimeType mtype => Produces CreateProject mtype


-- *** createProjectInvitation

-- | @POST \/api\/backend\/v1\/invitations\/project@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createProjectInvitation
  :: (Consumes CreateProjectInvitation contentType, MimeRender contentType NewProjectInvitationDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> NewProjectInvitationDTO -- ^ "newProjectInvitation"
  -> NeptuneBackendRequest CreateProjectInvitation contentType ProjectInvitationDTO accept
createProjectInvitation :: ContentType contentType
-> Accept accept
-> NewProjectInvitationDTO
-> NeptuneBackendRequest
     CreateProjectInvitation contentType ProjectInvitationDTO accept
createProjectInvitation ContentType contentType
_  Accept accept
_ NewProjectInvitationDTO
newProjectInvitation =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     CreateProjectInvitation contentType ProjectInvitationDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/invitations/project"]
    NeptuneBackendRequest
  CreateProjectInvitation contentType ProjectInvitationDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     CreateProjectInvitation contentType ProjectInvitationDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  CreateProjectInvitation contentType ProjectInvitationDTO accept
-> NewProjectInvitationDTO
-> NeptuneBackendRequest
     CreateProjectInvitation contentType ProjectInvitationDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` NewProjectInvitationDTO
newProjectInvitation

data CreateProjectInvitation
instance HasBodyParam CreateProjectInvitation NewProjectInvitationDTO

-- | @*/*@
instance MimeType mtype => Consumes CreateProjectInvitation mtype

-- | @*/*@
instance MimeType mtype => Produces CreateProjectInvitation mtype


-- *** createReservation

-- | @POST \/api\/backend\/v1\/reservations@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
createReservation
  :: (Consumes CreateReservation contentType, MimeRender contentType NewReservationDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> NewReservationDTO -- ^ "newReservation"
  -> NeptuneBackendRequest CreateReservation contentType res accept
createReservation :: ContentType contentType
-> Accept accept
-> NewReservationDTO
-> NeptuneBackendRequest CreateReservation contentType res accept
createReservation ContentType contentType
_  Accept accept
_ NewReservationDTO
newReservation =
  Method
-> [ByteString]
-> NeptuneBackendRequest CreateReservation contentType res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/reservations"]
    NeptuneBackendRequest CreateReservation contentType res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest CreateReservation contentType res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest CreateReservation contentType res accept
-> NewReservationDTO
-> NeptuneBackendRequest CreateReservation contentType res accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` NewReservationDTO
newReservation

data CreateReservation
instance HasBodyParam CreateReservation NewReservationDTO

-- | @*/*@
instance MimeType mtype => Consumes CreateReservation mtype

-- | @*/*@
instance MimeType mtype => Produces CreateReservation mtype


-- *** createSystemChannel

-- | @POST \/api\/backend\/v1\/channels\/system@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createSystemChannel
  :: (Consumes CreateSystemChannel contentType, MimeRender contentType ChannelParams)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ChannelParams -- ^ "channelToCreate"
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest CreateSystemChannel contentType ChannelDTO accept
createSystemChannel :: ContentType contentType
-> Accept accept
-> ChannelParams
-> ExperimentId
-> NeptuneBackendRequest
     CreateSystemChannel contentType ChannelDTO accept
createSystemChannel ContentType contentType
_  Accept accept
_ ChannelParams
channelToCreate (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     CreateSystemChannel contentType ChannelDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/channels/system"]
    NeptuneBackendRequest
  CreateSystemChannel contentType ChannelDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     CreateSystemChannel contentType ChannelDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  CreateSystemChannel contentType ChannelDTO accept
-> ChannelParams
-> NeptuneBackendRequest
     CreateSystemChannel contentType ChannelDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ChannelParams
channelToCreate
    NeptuneBackendRequest
  CreateSystemChannel contentType ChannelDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     CreateSystemChannel contentType ChannelDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
experimentId)

data CreateSystemChannel
instance HasBodyParam CreateSystemChannel ChannelParams

-- | @*/*@
instance MimeType mtype => Consumes CreateSystemChannel mtype

-- | @*/*@
instance MimeType mtype => Produces CreateSystemChannel mtype


-- *** createSystemMetric

-- | @POST \/api\/backend\/v1\/experiments\/{experimentId}\/system\/metrics@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
createSystemMetric
  :: (Consumes CreateSystemMetric contentType, MimeRender contentType SystemMetricParams)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> SystemMetricParams -- ^ "metricToCreate"
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest CreateSystemMetric contentType SystemMetric accept
createSystemMetric :: ContentType contentType
-> Accept accept
-> SystemMetricParams
-> ExperimentId
-> NeptuneBackendRequest
     CreateSystemMetric contentType SystemMetric accept
createSystemMetric ContentType contentType
_  Accept accept
_ SystemMetricParams
metricToCreate (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     CreateSystemMetric contentType SystemMetric accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/experiments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
experimentId,ByteString
"/system/metrics"]
    NeptuneBackendRequest
  CreateSystemMetric contentType SystemMetric accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     CreateSystemMetric contentType SystemMetric accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  CreateSystemMetric contentType SystemMetric accept
-> SystemMetricParams
-> NeptuneBackendRequest
     CreateSystemMetric contentType SystemMetric accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` SystemMetricParams
metricToCreate

data CreateSystemMetric
instance HasBodyParam CreateSystemMetric SystemMetricParams

-- | @*/*@
instance MimeType mtype => Consumes CreateSystemMetric mtype

-- | @*/*@
instance MimeType mtype => Produces CreateSystemMetric mtype


-- *** deleteChart

-- | @DELETE \/api\/backend\/v1\/chartSets\/{chartSetId}\/charts\/{chartId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
deleteChart
  :: Accept accept -- ^ request accept ('MimeType')
  -> ChartId -- ^ "chartId"
  -> ChartSetId -- ^ "chartSetId"
  -> NeptuneBackendRequest DeleteChart MimeNoContent res accept
deleteChart :: Accept accept
-> ChartId
-> ChartSetId
-> NeptuneBackendRequest DeleteChart MimeNoContent res accept
deleteChart  Accept accept
_ (ChartId Text
chartId) (ChartSetId Text
chartSetId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest DeleteChart MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/backend/v1/chartSets/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
chartSetId,ByteString
"/charts/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
chartId]
    NeptuneBackendRequest DeleteChart MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest DeleteChart MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data DeleteChart
-- | @*/*@
instance MimeType mtype => Produces DeleteChart mtype


-- *** deleteChartSet

-- | @DELETE \/api\/backend\/v1\/chartSets\/{chartSetId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
deleteChartSet
  :: Accept accept -- ^ request accept ('MimeType')
  -> ChartSetId -- ^ "chartSetId"
  -> NeptuneBackendRequest DeleteChartSet MimeNoContent res accept
deleteChartSet :: Accept accept
-> ChartSetId
-> NeptuneBackendRequest DeleteChartSet MimeNoContent res accept
deleteChartSet  Accept accept
_ (ChartSetId Text
chartSetId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest DeleteChartSet MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/backend/v1/chartSets/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
chartSetId]
    NeptuneBackendRequest DeleteChartSet MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest DeleteChartSet MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data DeleteChartSet
-- | @*/*@
instance MimeType mtype => Produces DeleteChartSet mtype


-- *** deleteExperimentOutput

-- | @DELETE \/api\/leaderboard\/v1\/storage\/deleteOutput@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
deleteExperimentOutput
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentIdentifier -- ^ "experimentIdentifier"
  -> Path -- ^ "path"
  -> NeptuneBackendRequest DeleteExperimentOutput MimeNoContent res accept
deleteExperimentOutput :: Accept accept
-> ExperimentIdentifier
-> Path
-> NeptuneBackendRequest
     DeleteExperimentOutput MimeNoContent res accept
deleteExperimentOutput  Accept accept
_ (ExperimentIdentifier Text
experimentIdentifier) (Path Text
path) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     DeleteExperimentOutput MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/leaderboard/v1/storage/deleteOutput"]
    NeptuneBackendRequest
  DeleteExperimentOutput MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     DeleteExperimentOutput MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  DeleteExperimentOutput MimeNoContent res accept
-> [QueryItem]
-> NeptuneBackendRequest
     DeleteExperimentOutput MimeNoContent res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
experimentIdentifier)
    NeptuneBackendRequest
  DeleteExperimentOutput MimeNoContent res accept
-> [QueryItem]
-> NeptuneBackendRequest
     DeleteExperimentOutput MimeNoContent res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"path", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
path)

data DeleteExperimentOutput
-- | @*/*@
instance MimeType mtype => Produces DeleteExperimentOutput mtype


-- *** deleteOrganization

-- | @DELETE \/api\/backend\/v1\/organizations2\/{organizationId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
deleteOrganization
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationId -- ^ "organizationId"
  -> NeptuneBackendRequest DeleteOrganization MimeNoContent res accept
deleteOrganization :: Accept accept
-> OrganizationId
-> NeptuneBackendRequest
     DeleteOrganization MimeNoContent res accept
deleteOrganization  Accept accept
_ (OrganizationId Text
organizationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     DeleteOrganization MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationId]
    NeptuneBackendRequest DeleteOrganization MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     DeleteOrganization MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data DeleteOrganization
-- | @*/*@
instance MimeType mtype => Produces DeleteOrganization mtype


-- *** deleteOrganizationMember

-- | @DELETE \/api\/backend\/v1\/organizations2\/{organizationIdentifier}\/members\/{userId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
deleteOrganizationMember
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> UserId -- ^ "userId"
  -> NeptuneBackendRequest DeleteOrganizationMember MimeNoContent res accept
deleteOrganizationMember :: Accept accept
-> OrganizationIdentifier
-> UserId
-> NeptuneBackendRequest
     DeleteOrganizationMember MimeNoContent res accept
deleteOrganizationMember  Accept accept
_ (OrganizationIdentifier Text
organizationIdentifier) (UserId Text
userId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     DeleteOrganizationMember MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/members/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
userId]
    NeptuneBackendRequest
  DeleteOrganizationMember MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     DeleteOrganizationMember MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data DeleteOrganizationMember
-- | @*/*@
instance MimeType mtype => Produces DeleteOrganizationMember mtype


-- *** deleteProject

-- | @DELETE \/api\/backend\/v1\/projects@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
deleteProject
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectIdentifier -- ^ "projectIdentifier"
  -> NeptuneBackendRequest DeleteProject MimeNoContent res accept
deleteProject :: Accept accept
-> ProjectIdentifier
-> NeptuneBackendRequest DeleteProject MimeNoContent res accept
deleteProject  Accept accept
_ (ProjectIdentifier Text
projectIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest DeleteProject MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/backend/v1/projects"]
    NeptuneBackendRequest DeleteProject MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest DeleteProject MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest DeleteProject MimeNoContent res accept
-> [QueryItem]
-> NeptuneBackendRequest DeleteProject MimeNoContent res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectIdentifier)

data DeleteProject
-- | @*/*@
instance MimeType mtype => Produces DeleteProject mtype


-- *** deleteProjectMember

-- | @DELETE \/api\/backend\/v1\/projects\/members\/{userId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
deleteProjectMember
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectIdentifier -- ^ "projectIdentifier"
  -> UserId -- ^ "userId"
  -> NeptuneBackendRequest DeleteProjectMember MimeNoContent res accept
deleteProjectMember :: Accept accept
-> ProjectIdentifier
-> UserId
-> NeptuneBackendRequest
     DeleteProjectMember MimeNoContent res accept
deleteProjectMember  Accept accept
_ (ProjectIdentifier Text
projectIdentifier) (UserId Text
userId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     DeleteProjectMember MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/backend/v1/projects/members/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
userId]
    NeptuneBackendRequest DeleteProjectMember MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     DeleteProjectMember MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest DeleteProjectMember MimeNoContent res accept
-> [QueryItem]
-> NeptuneBackendRequest
     DeleteProjectMember MimeNoContent res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectIdentifier)

data DeleteProjectMember
-- | @*/*@
instance MimeType mtype => Produces DeleteProjectMember mtype


-- *** deleteUserProfileLink

-- | @DELETE \/api\/backend\/v1\/userProfile\/links@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
deleteUserProfileLink
  :: (Consumes DeleteUserProfileLink contentType, MimeRender contentType LinkDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> LinkDTO -- ^ "link"
  -> NeptuneBackendRequest DeleteUserProfileLink contentType res accept
deleteUserProfileLink :: ContentType contentType
-> Accept accept
-> LinkDTO
-> NeptuneBackendRequest
     DeleteUserProfileLink contentType res accept
deleteUserProfileLink ContentType contentType
_  Accept accept
_ LinkDTO
link =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     DeleteUserProfileLink contentType res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/backend/v1/userProfile/links"]
    NeptuneBackendRequest DeleteUserProfileLink contentType res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     DeleteUserProfileLink contentType res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest DeleteUserProfileLink contentType res accept
-> LinkDTO
-> NeptuneBackendRequest
     DeleteUserProfileLink contentType res accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` LinkDTO
link

data DeleteUserProfileLink
instance HasBodyParam DeleteUserProfileLink LinkDTO

-- | @*/*@
instance MimeType mtype => Consumes DeleteUserProfileLink mtype

-- | @*/*@
instance MimeType mtype => Produces DeleteUserProfileLink mtype


-- *** deprecatedGetChannelValues

-- | @GET \/api\/backend\/v1\/channels\/{channelId}\/values@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
deprecatedGetChannelValues
  :: Accept accept -- ^ request accept ('MimeType')
  -> ChannelId -- ^ "channelId"
  -> NeptuneBackendRequest DeprecatedGetChannelValues MimeNoContent LimitedChannelValuesDTO accept
deprecatedGetChannelValues :: Accept accept
-> ChannelId
-> NeptuneBackendRequest
     DeprecatedGetChannelValues
     MimeNoContent
     LimitedChannelValuesDTO
     accept
deprecatedGetChannelValues  Accept accept
_ (ChannelId Text
channelId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     DeprecatedGetChannelValues
     MimeNoContent
     LimitedChannelValuesDTO
     accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/channels/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
channelId,ByteString
"/values"]
    NeptuneBackendRequest
  DeprecatedGetChannelValues
  MimeNoContent
  LimitedChannelValuesDTO
  accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     DeprecatedGetChannelValues
     MimeNoContent
     LimitedChannelValuesDTO
     accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data DeprecatedGetChannelValues
instance HasOptionalParam DeprecatedGetChannelValues Offset where
  applyOptionalParam :: NeptuneBackendRequest
  DeprecatedGetChannelValues contentType res accept
-> Offset
-> NeptuneBackendRequest
     DeprecatedGetChannelValues contentType res accept
applyOptionalParam NeptuneBackendRequest
  DeprecatedGetChannelValues contentType res accept
req (Offset Int
xs) =
    NeptuneBackendRequest
  DeprecatedGetChannelValues contentType res accept
req NeptuneBackendRequest
  DeprecatedGetChannelValues contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest
     DeprecatedGetChannelValues contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Int) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"offset", Int -> Maybe Int
forall a. a -> Maybe a
Just Int
xs)
instance HasOptionalParam DeprecatedGetChannelValues Limit where
  applyOptionalParam :: NeptuneBackendRequest
  DeprecatedGetChannelValues contentType res accept
-> Limit
-> NeptuneBackendRequest
     DeprecatedGetChannelValues contentType res accept
applyOptionalParam NeptuneBackendRequest
  DeprecatedGetChannelValues contentType res accept
req (Limit Int
xs) =
    NeptuneBackendRequest
  DeprecatedGetChannelValues contentType res accept
req NeptuneBackendRequest
  DeprecatedGetChannelValues contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest
     DeprecatedGetChannelValues contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Int) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"limit", Int -> Maybe Int
forall a. a -> Maybe a
Just Int
xs)
-- | @*/*@
instance MimeType mtype => Produces DeprecatedGetChannelValues mtype


-- *** deprecatedGetChannelValuesCSV

-- | @GET \/api\/backend\/v1\/channels\/{channelId}\/csv@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
deprecatedGetChannelValuesCSV
  :: Accept accept -- ^ request accept ('MimeType')
  -> ChannelId -- ^ "channelId"
  -> NeptuneBackendRequest DeprecatedGetChannelValuesCSV MimeNoContent res accept
deprecatedGetChannelValuesCSV :: Accept accept
-> ChannelId
-> NeptuneBackendRequest
     DeprecatedGetChannelValuesCSV MimeNoContent res accept
deprecatedGetChannelValuesCSV  Accept accept
_ (ChannelId Text
channelId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     DeprecatedGetChannelValuesCSV MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/channels/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
channelId,ByteString
"/csv"]
    NeptuneBackendRequest
  DeprecatedGetChannelValuesCSV MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     DeprecatedGetChannelValuesCSV MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data DeprecatedGetChannelValuesCSV
instance HasOptionalParam DeprecatedGetChannelValuesCSV ExperimentId where
  applyOptionalParam :: NeptuneBackendRequest
  DeprecatedGetChannelValuesCSV contentType res accept
-> ExperimentId
-> NeptuneBackendRequest
     DeprecatedGetChannelValuesCSV contentType res accept
applyOptionalParam NeptuneBackendRequest
  DeprecatedGetChannelValuesCSV contentType res accept
req (ExperimentId Text
xs) =
    NeptuneBackendRequest
  DeprecatedGetChannelValuesCSV contentType res accept
req NeptuneBackendRequest
  DeprecatedGetChannelValuesCSV contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest
     DeprecatedGetChannelValuesCSV contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam DeprecatedGetChannelValuesCSV Gzipped where
  applyOptionalParam :: NeptuneBackendRequest
  DeprecatedGetChannelValuesCSV contentType res accept
-> Gzipped
-> NeptuneBackendRequest
     DeprecatedGetChannelValuesCSV contentType res accept
applyOptionalParam NeptuneBackendRequest
  DeprecatedGetChannelValuesCSV contentType res accept
req (Gzipped Bool
xs) =
    NeptuneBackendRequest
  DeprecatedGetChannelValuesCSV contentType res accept
req NeptuneBackendRequest
  DeprecatedGetChannelValuesCSV contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest
     DeprecatedGetChannelValuesCSV contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Bool) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"gzipped", Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
xs)
-- | @*/*@
instance MimeType mtype => Produces DeprecatedGetChannelValuesCSV mtype


-- *** downgradeTeamOrganization

-- | @DELETE \/api\/backend\/v1\/payments\/{organizationIdentifier}\/downgrade@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
downgradeTeamOrganization
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> NeptuneBackendRequest DowngradeTeamOrganization MimeNoContent res accept
downgradeTeamOrganization :: Accept accept
-> OrganizationIdentifier
-> NeptuneBackendRequest
     DowngradeTeamOrganization MimeNoContent res accept
downgradeTeamOrganization  Accept accept
_ (OrganizationIdentifier Text
organizationIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     DowngradeTeamOrganization MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/backend/v1/payments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/downgrade"]
    NeptuneBackendRequest
  DowngradeTeamOrganization MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     DowngradeTeamOrganization MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data DowngradeTeamOrganization
-- | @*/*@
instance MimeType mtype => Produces DowngradeTeamOrganization mtype


-- *** downloadData

-- | @GET \/api\/leaderboard\/v1\/storage\/legacy\/download@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
downloadData
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectId -- ^ "projectId"
  -> Path -- ^ "path"
  -> NeptuneBackendRequest DownloadData MimeNoContent res accept
downloadData :: Accept accept
-> ProjectId
-> Path
-> NeptuneBackendRequest DownloadData MimeNoContent res accept
downloadData  Accept accept
_ (ProjectId Text
projectId) (Path Text
path) =
  Method
-> [ByteString]
-> NeptuneBackendRequest DownloadData MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/leaderboard/v1/storage/legacy/download"]
    NeptuneBackendRequest DownloadData MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest DownloadData MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest DownloadData MimeNoContent res accept
-> [QueryItem]
-> NeptuneBackendRequest DownloadData MimeNoContent res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectId)
    NeptuneBackendRequest DownloadData MimeNoContent res accept
-> [QueryItem]
-> NeptuneBackendRequest DownloadData MimeNoContent res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"path", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
path)

data DownloadData
-- | @*/*@
instance MimeType mtype => Produces DownloadData mtype


-- *** emptyExperimentsTrash

-- | @POST \/api\/leaderboard\/v1\/experiments\/trash\/empty@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
emptyExperimentsTrash
  :: (Consumes EmptyExperimentsTrash contentType, MimeRender contentType ExperimentIds)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ExperimentIds -- ^ "experimentIds"
  -> NeptuneBackendRequest EmptyExperimentsTrash contentType [BatchExperimentUpdateResult] accept
emptyExperimentsTrash :: ContentType contentType
-> Accept accept
-> ExperimentIds
-> NeptuneBackendRequest
     EmptyExperimentsTrash
     contentType
     [BatchExperimentUpdateResult]
     accept
emptyExperimentsTrash ContentType contentType
_  Accept accept
_ ExperimentIds
experimentIds =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     EmptyExperimentsTrash
     contentType
     [BatchExperimentUpdateResult]
     accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/experiments/trash/empty"]
    NeptuneBackendRequest
  EmptyExperimentsTrash
  contentType
  [BatchExperimentUpdateResult]
  accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     EmptyExperimentsTrash
     contentType
     [BatchExperimentUpdateResult]
     accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  EmptyExperimentsTrash
  contentType
  [BatchExperimentUpdateResult]
  accept
-> ExperimentIds
-> NeptuneBackendRequest
     EmptyExperimentsTrash
     contentType
     [BatchExperimentUpdateResult]
     accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ExperimentIds
experimentIds

data EmptyExperimentsTrash
instance HasBodyParam EmptyExperimentsTrash ExperimentIds

-- | @*/*@
instance MimeType mtype => Consumes EmptyExperimentsTrash mtype

-- | @*/*@
instance MimeType mtype => Produces EmptyExperimentsTrash mtype


-- *** exchangeApiToken

-- | @GET \/api\/backend\/v1\/authorization\/oauth-token@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
exchangeApiToken
  :: Accept accept -- ^ request accept ('MimeType')
  -> XNeptuneApiToken -- ^ "xNeptuneApiToken"
  -> NeptuneBackendRequest ExchangeApiToken MimeNoContent NeptuneOauthToken accept
exchangeApiToken :: Accept accept
-> XNeptuneApiToken
-> NeptuneBackendRequest
     ExchangeApiToken MimeNoContent NeptuneOauthToken accept
exchangeApiToken  Accept accept
_ (XNeptuneApiToken Text
xNeptuneApiToken) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ExchangeApiToken MimeNoContent NeptuneOauthToken accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/authorization/oauth-token"]
    NeptuneBackendRequest
  ExchangeApiToken MimeNoContent NeptuneOauthToken accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     ExchangeApiToken MimeNoContent NeptuneOauthToken accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  ExchangeApiToken MimeNoContent NeptuneOauthToken accept
-> [Header]
-> NeptuneBackendRequest
     ExchangeApiToken MimeNoContent NeptuneOauthToken accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [Header] -> NeptuneBackendRequest req contentType res accept
`addHeader` (HeaderName, Text) -> [Header]
forall a. ToHttpApiData a => (HeaderName, a) -> [Header]
toHeader (HeaderName
"X-Neptune-Api-Token", Text
xNeptuneApiToken)

data ExchangeApiToken
-- | @*/*@
instance MimeType mtype => Produces ExchangeApiToken mtype


-- *** filterOrganizations

-- | @GET \/api\/backend\/v1\/organizations2@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
filterOrganizations
  :: Accept accept -- ^ request accept ('MimeType')
  -> Ids -- ^ "ids"
  -> NeptuneBackendRequest FilterOrganizations MimeNoContent [OrganizationDTO] accept
filterOrganizations :: Accept accept
-> Ids
-> NeptuneBackendRequest
     FilterOrganizations MimeNoContent [OrganizationDTO] accept
filterOrganizations  Accept accept
_ (Ids [Text]
ids) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     FilterOrganizations MimeNoContent [OrganizationDTO] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/organizations2"]
    NeptuneBackendRequest
  FilterOrganizations MimeNoContent [OrganizationDTO] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     FilterOrganizations MimeNoContent [OrganizationDTO] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  FilterOrganizations MimeNoContent [OrganizationDTO] accept
-> [QueryItem]
-> NeptuneBackendRequest
     FilterOrganizations MimeNoContent [OrganizationDTO] accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` CollectionFormat -> (Method, Maybe [Text]) -> [QueryItem]
forall a.
ToHttpApiData a =>
CollectionFormat -> (Method, Maybe [a]) -> [QueryItem]
toQueryColl CollectionFormat
MultiParamArray (Method
"ids", [Text] -> Maybe [Text]
forall a. a -> Maybe a
Just [Text]
ids)

data FilterOrganizations
-- | @*/*@
instance MimeType mtype => Produces FilterOrganizations mtype


-- *** generateProjectKey

-- | @GET \/api\/backend\/v1\/projects\/key@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
generateProjectKey
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationId -- ^ "organizationId"
  -> ProjectName -- ^ "projectName"
  -> NeptuneBackendRequest GenerateProjectKey MimeNoContent ProjectKeyDTO accept
generateProjectKey :: Accept accept
-> OrganizationId
-> ProjectName
-> NeptuneBackendRequest
     GenerateProjectKey MimeNoContent ProjectKeyDTO accept
generateProjectKey  Accept accept
_ (OrganizationId Text
organizationId) (ProjectName Text
projectName) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GenerateProjectKey MimeNoContent ProjectKeyDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/projects/key"]
    NeptuneBackendRequest
  GenerateProjectKey MimeNoContent ProjectKeyDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GenerateProjectKey MimeNoContent ProjectKeyDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  GenerateProjectKey MimeNoContent ProjectKeyDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     GenerateProjectKey MimeNoContent ProjectKeyDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"organizationId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
organizationId)
    NeptuneBackendRequest
  GenerateProjectKey MimeNoContent ProjectKeyDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     GenerateProjectKey MimeNoContent ProjectKeyDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectName", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectName)

data GenerateProjectKey
-- | @*/*@
instance MimeType mtype => Produces GenerateProjectKey mtype


-- *** getAchievements

-- | @GET \/api\/backend\/v1\/achievements@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getAchievements
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest GetAchievements MimeNoContent AchievementsDTO accept
getAchievements :: Accept accept
-> NeptuneBackendRequest
     GetAchievements MimeNoContent AchievementsDTO accept
getAchievements  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetAchievements MimeNoContent AchievementsDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/achievements"]
    NeptuneBackendRequest
  GetAchievements MimeNoContent AchievementsDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetAchievements MimeNoContent AchievementsDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetAchievements
-- | @*/*@
instance MimeType mtype => Produces GetAchievements mtype


-- *** getApiToken

-- | @GET \/api\/backend\/v1\/authorization\/api-token@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getApiToken
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest GetApiToken MimeNoContent NeptuneApiToken accept
getApiToken :: Accept accept
-> NeptuneBackendRequest
     GetApiToken MimeNoContent NeptuneApiToken accept
getApiToken  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetApiToken MimeNoContent NeptuneApiToken accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/authorization/api-token"]
    NeptuneBackendRequest
  GetApiToken MimeNoContent NeptuneApiToken accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetApiToken MimeNoContent NeptuneApiToken accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetApiToken
-- | @*/*@
instance MimeType mtype => Produces GetApiToken mtype


-- *** getChannelValues

-- | @GET \/api\/leaderboard\/v1\/channels\/{channelId}\/values@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getChannelValues
  :: Accept accept -- ^ request accept ('MimeType')
  -> ChannelId -- ^ "channelId"
  -> NeptuneBackendRequest GetChannelValues MimeNoContent LimitedChannelValuesDTO accept
getChannelValues :: Accept accept
-> ChannelId
-> NeptuneBackendRequest
     GetChannelValues MimeNoContent LimitedChannelValuesDTO accept
getChannelValues  Accept accept
_ (ChannelId Text
channelId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetChannelValues MimeNoContent LimitedChannelValuesDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/leaderboard/v1/channels/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
channelId,ByteString
"/values"]
    NeptuneBackendRequest
  GetChannelValues MimeNoContent LimitedChannelValuesDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetChannelValues MimeNoContent LimitedChannelValuesDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetChannelValues
instance HasOptionalParam GetChannelValues Offset where
  applyOptionalParam :: NeptuneBackendRequest GetChannelValues contentType res accept
-> Offset
-> NeptuneBackendRequest GetChannelValues contentType res accept
applyOptionalParam NeptuneBackendRequest GetChannelValues contentType res accept
req (Offset Int
xs) =
    NeptuneBackendRequest GetChannelValues contentType res accept
req NeptuneBackendRequest GetChannelValues contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest GetChannelValues contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Int) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"offset", Int -> Maybe Int
forall a. a -> Maybe a
Just Int
xs)
instance HasOptionalParam GetChannelValues Limit where
  applyOptionalParam :: NeptuneBackendRequest GetChannelValues contentType res accept
-> Limit
-> NeptuneBackendRequest GetChannelValues contentType res accept
applyOptionalParam NeptuneBackendRequest GetChannelValues contentType res accept
req (Limit Int
xs) =
    NeptuneBackendRequest GetChannelValues contentType res accept
req NeptuneBackendRequest GetChannelValues contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest GetChannelValues contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Int) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"limit", Int -> Maybe Int
forall a. a -> Maybe a
Just Int
xs)
-- | @*/*@
instance MimeType mtype => Produces GetChannelValues mtype


-- *** getChannelValuesCSV

-- | @GET \/api\/leaderboard\/v1\/channels\/{channelId}\/csv@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
getChannelValuesCSV
  :: Accept accept -- ^ request accept ('MimeType')
  -> ChannelId -- ^ "channelId"
  -> NeptuneBackendRequest GetChannelValuesCSV MimeNoContent res accept
getChannelValuesCSV :: Accept accept
-> ChannelId
-> NeptuneBackendRequest
     GetChannelValuesCSV MimeNoContent res accept
getChannelValuesCSV  Accept accept
_ (ChannelId Text
channelId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetChannelValuesCSV MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/leaderboard/v1/channels/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
channelId,ByteString
"/csv"]
    NeptuneBackendRequest GetChannelValuesCSV MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetChannelValuesCSV MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetChannelValuesCSV
instance HasOptionalParam GetChannelValuesCSV ExperimentId where
  applyOptionalParam :: NeptuneBackendRequest GetChannelValuesCSV contentType res accept
-> ExperimentId
-> NeptuneBackendRequest GetChannelValuesCSV contentType res accept
applyOptionalParam NeptuneBackendRequest GetChannelValuesCSV contentType res accept
req (ExperimentId Text
xs) =
    NeptuneBackendRequest GetChannelValuesCSV contentType res accept
req NeptuneBackendRequest GetChannelValuesCSV contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest GetChannelValuesCSV contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam GetChannelValuesCSV Gzipped where
  applyOptionalParam :: NeptuneBackendRequest GetChannelValuesCSV contentType res accept
-> Gzipped
-> NeptuneBackendRequest GetChannelValuesCSV contentType res accept
applyOptionalParam NeptuneBackendRequest GetChannelValuesCSV contentType res accept
req (Gzipped Bool
xs) =
    NeptuneBackendRequest GetChannelValuesCSV contentType res accept
req NeptuneBackendRequest GetChannelValuesCSV contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest GetChannelValuesCSV contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Bool) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"gzipped", Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
xs)
-- | @*/*@
instance MimeType mtype => Produces GetChannelValuesCSV mtype


-- *** getChannelsLastValues

-- | @GET \/api\/backend\/v1\/channels\/lastValues@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getChannelsLastValues
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest GetChannelsLastValues MimeNoContent [ChannelWithValueDTO] accept
getChannelsLastValues :: Accept accept
-> ExperimentId
-> NeptuneBackendRequest
     GetChannelsLastValues MimeNoContent [ChannelWithValueDTO] accept
getChannelsLastValues  Accept accept
_ (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetChannelsLastValues MimeNoContent [ChannelWithValueDTO] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/channels/lastValues"]
    NeptuneBackendRequest
  GetChannelsLastValues MimeNoContent [ChannelWithValueDTO] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetChannelsLastValues MimeNoContent [ChannelWithValueDTO] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  GetChannelsLastValues MimeNoContent [ChannelWithValueDTO] accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetChannelsLastValues MimeNoContent [ChannelWithValueDTO] accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
experimentId)

data GetChannelsLastValues
-- | @*/*@
instance MimeType mtype => Produces GetChannelsLastValues mtype


-- *** getChartSet

-- | @GET \/api\/backend\/v1\/chartSets\/{chartSetId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getChartSet
  :: Accept accept -- ^ request accept ('MimeType')
  -> ChartSetId -- ^ "chartSetId"
  -> NeptuneBackendRequest GetChartSet MimeNoContent ChartSet accept
getChartSet :: Accept accept
-> ChartSetId
-> NeptuneBackendRequest GetChartSet MimeNoContent ChartSet accept
getChartSet  Accept accept
_ (ChartSetId Text
chartSetId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest GetChartSet MimeNoContent ChartSet accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/chartSets/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
chartSetId]
    NeptuneBackendRequest GetChartSet MimeNoContent ChartSet accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest GetChartSet MimeNoContent ChartSet accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetChartSet
-- | @*/*@
instance MimeType mtype => Produces GetChartSet mtype


-- *** getClientConfig

-- | @GET \/api\/backend\/v1\/clients\/config@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getClientConfig
  :: Accept accept -- ^ request accept ('MimeType')
  -> XNeptuneApiToken -- ^ "xNeptuneApiToken"
  -> NeptuneBackendRequest GetClientConfig MimeNoContent ClientConfig accept
getClientConfig :: Accept accept
-> XNeptuneApiToken
-> NeptuneBackendRequest
     GetClientConfig MimeNoContent ClientConfig accept
getClientConfig  Accept accept
_ (XNeptuneApiToken Text
xNeptuneApiToken) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetClientConfig MimeNoContent ClientConfig accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/clients/config"]
    NeptuneBackendRequest
  GetClientConfig MimeNoContent ClientConfig accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetClientConfig MimeNoContent ClientConfig accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  GetClientConfig MimeNoContent ClientConfig accept
-> [Header]
-> NeptuneBackendRequest
     GetClientConfig MimeNoContent ClientConfig accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [Header] -> NeptuneBackendRequest req contentType res accept
`addHeader` (HeaderName, Text) -> [Header]
forall a. ToHttpApiData a => (HeaderName, a) -> [Header]
toHeader (HeaderName
"X-Neptune-Api-Token", Text
xNeptuneApiToken)

data GetClientConfig
-- | @*/*@
instance MimeType mtype => Produces GetClientConfig mtype


-- *** getCreditCard

-- | @GET \/api\/backend\/v1\/payments\/{organizationIdentifier}\/creditCard@
--
-- Returns a Stripe Source object
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getCreditCard
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> NeptuneBackendRequest GetCreditCard MimeNoContent Text accept
getCreditCard :: Accept accept
-> OrganizationIdentifier
-> NeptuneBackendRequest GetCreditCard MimeNoContent Text accept
getCreditCard  Accept accept
_ (OrganizationIdentifier Text
organizationIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest GetCreditCard MimeNoContent Text accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/payments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/creditCard"]
    NeptuneBackendRequest GetCreditCard MimeNoContent Text accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest GetCreditCard MimeNoContent Text accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetCreditCard
-- | @*/*@
instance MimeType mtype => Produces GetCreditCard mtype


-- *** getCustomer

-- | @GET \/api\/backend\/v1\/payments\/{organizationIdentifier}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getCustomer
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> NeptuneBackendRequest GetCustomer MimeNoContent CustomerDTO accept
getCustomer :: Accept accept
-> OrganizationIdentifier
-> NeptuneBackendRequest
     GetCustomer MimeNoContent CustomerDTO accept
getCustomer  Accept accept
_ (OrganizationIdentifier Text
organizationIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetCustomer MimeNoContent CustomerDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/payments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier]
    NeptuneBackendRequest GetCustomer MimeNoContent CustomerDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetCustomer MimeNoContent CustomerDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetCustomer
-- | @*/*@
instance MimeType mtype => Produces GetCustomer mtype


-- *** getDownloadPrepareRequest

-- | @GET \/api\/leaderboard\/v1\/storage\/downloadRequest@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getDownloadPrepareRequest
  :: Accept accept -- ^ request accept ('MimeType')
  -> Id -- ^ "id"
  -> NeptuneBackendRequest GetDownloadPrepareRequest MimeNoContent DownloadPrepareRequestDTO accept
getDownloadPrepareRequest :: Accept accept
-> Id
-> NeptuneBackendRequest
     GetDownloadPrepareRequest
     MimeNoContent
     DownloadPrepareRequestDTO
     accept
getDownloadPrepareRequest  Accept accept
_ (Id Text
id) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetDownloadPrepareRequest
     MimeNoContent
     DownloadPrepareRequestDTO
     accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/leaderboard/v1/storage/downloadRequest"]
    NeptuneBackendRequest
  GetDownloadPrepareRequest
  MimeNoContent
  DownloadPrepareRequestDTO
  accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetDownloadPrepareRequest
     MimeNoContent
     DownloadPrepareRequestDTO
     accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  GetDownloadPrepareRequest
  MimeNoContent
  DownloadPrepareRequestDTO
  accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetDownloadPrepareRequest
     MimeNoContent
     DownloadPrepareRequestDTO
     accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"id", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
id)

data GetDownloadPrepareRequest
-- | @*/*@
instance MimeType mtype => Produces GetDownloadPrepareRequest mtype


-- *** getExperiment

-- | @GET \/api\/leaderboard\/v1\/experiments@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getExperiment
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest GetExperiment MimeNoContent Experiment accept
getExperiment :: Accept accept
-> ExperimentId
-> NeptuneBackendRequest
     GetExperiment MimeNoContent Experiment accept
getExperiment  Accept accept
_ (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetExperiment MimeNoContent Experiment accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/leaderboard/v1/experiments"]
    NeptuneBackendRequest GetExperiment MimeNoContent Experiment accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetExperiment MimeNoContent Experiment accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest GetExperiment MimeNoContent Experiment accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetExperiment MimeNoContent Experiment accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
experimentId)

data GetExperiment
-- | @*/*@
instance MimeType mtype => Produces GetExperiment mtype


-- *** getExperimentCharts

-- | @GET \/api\/backend\/v1\/experiments\/{experimentId}\/charts@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getExperimentCharts
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> ChartSetId -- ^ "chartSetId"
  -> NeptuneBackendRequest GetExperimentCharts MimeNoContent Charts accept
getExperimentCharts :: Accept accept
-> ExperimentId
-> ChartSetId
-> NeptuneBackendRequest
     GetExperimentCharts MimeNoContent Charts accept
getExperimentCharts  Accept accept
_ (ExperimentId Text
experimentId) (ChartSetId Text
chartSetId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetExperimentCharts MimeNoContent Charts accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/experiments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
experimentId,ByteString
"/charts"]
    NeptuneBackendRequest
  GetExperimentCharts MimeNoContent Charts accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetExperimentCharts MimeNoContent Charts accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  GetExperimentCharts MimeNoContent Charts accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetExperimentCharts MimeNoContent Charts accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"chartSetId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
chartSetId)

data GetExperimentCharts
-- | @*/*@
instance MimeType mtype => Produces GetExperimentCharts mtype


-- *** getExperimentsAttributesNames

-- | @GET \/api\/leaderboard\/v1\/experiments-attributes-names@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getExperimentsAttributesNames
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectIdentifier -- ^ "projectIdentifier"
  -> NeptuneBackendRequest GetExperimentsAttributesNames MimeNoContent ExperimentsAttributesNamesDTO accept
getExperimentsAttributesNames :: Accept accept
-> ProjectIdentifier
-> NeptuneBackendRequest
     GetExperimentsAttributesNames
     MimeNoContent
     ExperimentsAttributesNamesDTO
     accept
getExperimentsAttributesNames  Accept accept
_ (ProjectIdentifier Text
projectIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetExperimentsAttributesNames
     MimeNoContent
     ExperimentsAttributesNamesDTO
     accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/leaderboard/v1/experiments-attributes-names"]
    NeptuneBackendRequest
  GetExperimentsAttributesNames
  MimeNoContent
  ExperimentsAttributesNamesDTO
  accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetExperimentsAttributesNames
     MimeNoContent
     ExperimentsAttributesNamesDTO
     accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  GetExperimentsAttributesNames
  MimeNoContent
  ExperimentsAttributesNamesDTO
  accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetExperimentsAttributesNames
     MimeNoContent
     ExperimentsAttributesNamesDTO
     accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectIdentifier)

data GetExperimentsAttributesNames
-- | @*/*@
instance MimeType mtype => Produces GetExperimentsAttributesNames mtype


-- *** getLoginActions

-- | @GET \/api\/backend\/v1\/login\/actions@
--
-- Returns a list of actions that backend requires the user to complete before he can start working with Neptune
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getLoginActions
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest GetLoginActions MimeNoContent LoginActionsListDTO accept
getLoginActions :: Accept accept
-> NeptuneBackendRequest
     GetLoginActions MimeNoContent LoginActionsListDTO accept
getLoginActions  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetLoginActions MimeNoContent LoginActionsListDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/login/actions"]
    NeptuneBackendRequest
  GetLoginActions MimeNoContent LoginActionsListDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetLoginActions MimeNoContent LoginActionsListDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetLoginActions
-- | @*/*@
instance MimeType mtype => Produces GetLoginActions mtype


-- *** getOrganization

-- | @GET \/api\/backend\/v1\/organizations2\/{organization}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getOrganization
  :: Accept accept -- ^ request accept ('MimeType')
  -> Organization -- ^ "organization"
  -> NeptuneBackendRequest GetOrganization MimeNoContent OrganizationDTO accept
getOrganization :: Accept accept
-> Organization
-> NeptuneBackendRequest
     GetOrganization MimeNoContent OrganizationDTO accept
getOrganization  Accept accept
_ (Organization Text
organization) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetOrganization MimeNoContent OrganizationDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organization]
    NeptuneBackendRequest
  GetOrganization MimeNoContent OrganizationDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetOrganization MimeNoContent OrganizationDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetOrganization
-- | @*/*@
instance MimeType mtype => Produces GetOrganization mtype


-- *** getOrganizationAvatar

-- | @GET \/api\/backend\/v1\/organizations2\/{organizationName}\/avatar@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
getOrganizationAvatar
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationName -- ^ "organizationName"
  -> NeptuneBackendRequest GetOrganizationAvatar MimeNoContent res accept
getOrganizationAvatar :: Accept accept
-> OrganizationName
-> NeptuneBackendRequest
     GetOrganizationAvatar MimeNoContent res accept
getOrganizationAvatar  Accept accept
_ (OrganizationName Text
organizationName) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetOrganizationAvatar MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationName,ByteString
"/avatar"]
    NeptuneBackendRequest
  GetOrganizationAvatar MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetOrganizationAvatar MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetOrganizationAvatar
-- | @*/*@
instance MimeType mtype => Produces GetOrganizationAvatar mtype


-- *** getOrganizationInvitation

-- | @GET \/api\/backend\/v1\/invitations\/organization\/{invitationId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getOrganizationInvitation
  :: Accept accept -- ^ request accept ('MimeType')
  -> InvitationId -- ^ "invitationId"
  -> NeptuneBackendRequest GetOrganizationInvitation MimeNoContent OrganizationInvitationDTO accept
getOrganizationInvitation :: Accept accept
-> InvitationId
-> NeptuneBackendRequest
     GetOrganizationInvitation
     MimeNoContent
     OrganizationInvitationDTO
     accept
getOrganizationInvitation  Accept accept
_ (InvitationId Text
invitationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetOrganizationInvitation
     MimeNoContent
     OrganizationInvitationDTO
     accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/invitations/organization/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
invitationId]
    NeptuneBackendRequest
  GetOrganizationInvitation
  MimeNoContent
  OrganizationInvitationDTO
  accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetOrganizationInvitation
     MimeNoContent
     OrganizationInvitationDTO
     accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetOrganizationInvitation
-- | @*/*@
instance MimeType mtype => Produces GetOrganizationInvitation mtype


-- *** getOrganizationLimits

-- | @GET \/api\/backend\/v1\/organizations2\/{organizationIdentifier}\/limits@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getOrganizationLimits
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> NeptuneBackendRequest GetOrganizationLimits MimeNoContent OrganizationLimitsDTO accept
getOrganizationLimits :: Accept accept
-> OrganizationIdentifier
-> NeptuneBackendRequest
     GetOrganizationLimits MimeNoContent OrganizationLimitsDTO accept
getOrganizationLimits  Accept accept
_ (OrganizationIdentifier Text
organizationIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetOrganizationLimits MimeNoContent OrganizationLimitsDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/limits"]
    NeptuneBackendRequest
  GetOrganizationLimits MimeNoContent OrganizationLimitsDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetOrganizationLimits MimeNoContent OrganizationLimitsDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetOrganizationLimits
-- | @*/*@
instance MimeType mtype => Produces GetOrganizationLimits mtype


-- *** getPastInvoices

-- | @GET \/api\/backend\/v1\/payments\/{organizationIdentifier}\/invoices\/past@
--
-- Pass-through to Stripe /v1/invoices
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getPastInvoices
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> NeptuneBackendRequest GetPastInvoices MimeNoContent Text accept
getPastInvoices :: Accept accept
-> OrganizationIdentifier
-> NeptuneBackendRequest GetPastInvoices MimeNoContent Text accept
getPastInvoices  Accept accept
_ (OrganizationIdentifier Text
organizationIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest GetPastInvoices MimeNoContent Text accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/payments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/invoices/past"]
    NeptuneBackendRequest GetPastInvoices MimeNoContent Text accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest GetPastInvoices MimeNoContent Text accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetPastInvoices
-- | @*/*@
instance MimeType mtype => Produces GetPastInvoices mtype


-- *** getPricingPlan

-- | @GET \/api\/backend\/v1\/payments\/{organizationIdentifier}\/pricingPlan@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getPricingPlan
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> NeptuneBackendRequest GetPricingPlan MimeNoContent OrganizationPricingPlanDTO accept
getPricingPlan :: Accept accept
-> OrganizationIdentifier
-> NeptuneBackendRequest
     GetPricingPlan MimeNoContent OrganizationPricingPlanDTO accept
getPricingPlan  Accept accept
_ (OrganizationIdentifier Text
organizationIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetPricingPlan MimeNoContent OrganizationPricingPlanDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/payments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/pricingPlan"]
    NeptuneBackendRequest
  GetPricingPlan MimeNoContent OrganizationPricingPlanDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetPricingPlan MimeNoContent OrganizationPricingPlanDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetPricingPlan
-- | @*/*@
instance MimeType mtype => Produces GetPricingPlan mtype


-- *** getProject

-- | @GET \/api\/backend\/v1\/projects\/get@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getProject
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectIdentifier -- ^ "projectIdentifier"
  -> NeptuneBackendRequest GetProject MimeNoContent ProjectWithRoleDTO accept
getProject :: Accept accept
-> ProjectIdentifier
-> NeptuneBackendRequest
     GetProject MimeNoContent ProjectWithRoleDTO accept
getProject  Accept accept
_ (ProjectIdentifier Text
projectIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetProject MimeNoContent ProjectWithRoleDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/projects/get"]
    NeptuneBackendRequest
  GetProject MimeNoContent ProjectWithRoleDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetProject MimeNoContent ProjectWithRoleDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  GetProject MimeNoContent ProjectWithRoleDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetProject MimeNoContent ProjectWithRoleDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectIdentifier)

data GetProject
-- | @*/*@
instance MimeType mtype => Produces GetProject mtype


-- *** getProjectAvatar

-- | @GET \/api\/backend\/v1\/organizations\/{organizationName}\/projects\/{projectName}\/avatar@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
getProjectAvatar
  :: OrganizationName -- ^ "organizationName"
  -> ProjectName -- ^ "projectName"
  -> NeptuneBackendRequest GetProjectAvatar MimeNoContent res MimeImagePng
getProjectAvatar :: OrganizationName
-> ProjectName
-> NeptuneBackendRequest
     GetProjectAvatar MimeNoContent res MimeImagePng
getProjectAvatar (OrganizationName Text
organizationName) (ProjectName Text
projectName) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetProjectAvatar MimeNoContent res MimeImagePng
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/organizations/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationName,ByteString
"/projects/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
projectName,ByteString
"/avatar"]
    NeptuneBackendRequest
  GetProjectAvatar MimeNoContent res MimeImagePng
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetProjectAvatar MimeNoContent res MimeImagePng
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetProjectAvatar
-- | @image/png@
instance Produces GetProjectAvatar MimeImagePng


-- *** getProjectBackground

-- | @GET \/api\/backend\/v1\/organizations\/{organizationName}\/projects\/{projectName}\/background@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
getProjectBackground
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationName -- ^ "organizationName"
  -> ProjectName -- ^ "projectName"
  -> NeptuneBackendRequest GetProjectBackground MimeNoContent res accept
getProjectBackground :: Accept accept
-> OrganizationName
-> ProjectName
-> NeptuneBackendRequest
     GetProjectBackground MimeNoContent res accept
getProjectBackground  Accept accept
_ (OrganizationName Text
organizationName) (ProjectName Text
projectName) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetProjectBackground MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/organizations/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationName,ByteString
"/projects/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
projectName,ByteString
"/background"]
    NeptuneBackendRequest GetProjectBackground MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetProjectBackground MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetProjectBackground
-- | @*/*@
instance MimeType mtype => Produces GetProjectBackground mtype


-- *** getProjectInvitation

-- | @GET \/api\/backend\/v1\/invitations\/project\/{invitationId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getProjectInvitation
  :: Accept accept -- ^ request accept ('MimeType')
  -> InvitationId -- ^ "invitationId"
  -> NeptuneBackendRequest GetProjectInvitation MimeNoContent ProjectInvitationDTO accept
getProjectInvitation :: Accept accept
-> InvitationId
-> NeptuneBackendRequest
     GetProjectInvitation MimeNoContent ProjectInvitationDTO accept
getProjectInvitation  Accept accept
_ (InvitationId Text
invitationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetProjectInvitation MimeNoContent ProjectInvitationDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/invitations/project/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
invitationId]
    NeptuneBackendRequest
  GetProjectInvitation MimeNoContent ProjectInvitationDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetProjectInvitation MimeNoContent ProjectInvitationDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetProjectInvitation
-- | @*/*@
instance MimeType mtype => Produces GetProjectInvitation mtype


-- *** getProjectMetadata

-- | @GET \/api\/backend\/v1\/projects\/metadata@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getProjectMetadata
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectIdentifier -- ^ "projectIdentifier"
  -> NeptuneBackendRequest GetProjectMetadata MimeNoContent ProjectMetadataDTO accept
getProjectMetadata :: Accept accept
-> ProjectIdentifier
-> NeptuneBackendRequest
     GetProjectMetadata MimeNoContent ProjectMetadataDTO accept
getProjectMetadata  Accept accept
_ (ProjectIdentifier Text
projectIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetProjectMetadata MimeNoContent ProjectMetadataDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/projects/metadata"]
    NeptuneBackendRequest
  GetProjectMetadata MimeNoContent ProjectMetadataDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetProjectMetadata MimeNoContent ProjectMetadataDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  GetProjectMetadata MimeNoContent ProjectMetadataDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetProjectMetadata MimeNoContent ProjectMetadataDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectIdentifier)

data GetProjectMetadata
-- | @*/*@
instance MimeType mtype => Produces GetProjectMetadata mtype


-- *** getSsoConfig

-- | @GET \/api\/backend\/v1\/clients\/sso@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getSsoConfig
  :: Accept accept -- ^ request accept ('MimeType')
  -> WorkspaceName -- ^ "workspaceName"
  -> NeptuneBackendRequest GetSsoConfig MimeNoContent WorkspaceConfig accept
getSsoConfig :: Accept accept
-> WorkspaceName
-> NeptuneBackendRequest
     GetSsoConfig MimeNoContent WorkspaceConfig accept
getSsoConfig  Accept accept
_ (WorkspaceName Text
workspaceName) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetSsoConfig MimeNoContent WorkspaceConfig accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/clients/sso"]
    NeptuneBackendRequest
  GetSsoConfig MimeNoContent WorkspaceConfig accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetSsoConfig MimeNoContent WorkspaceConfig accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  GetSsoConfig MimeNoContent WorkspaceConfig accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetSsoConfig MimeNoContent WorkspaceConfig accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"workspaceName", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
workspaceName)

data GetSsoConfig
-- | @*/*@
instance MimeType mtype => Produces GetSsoConfig mtype


-- *** getSystemChannels

-- | @GET \/api\/backend\/v1\/channels\/system@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getSystemChannels
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest GetSystemChannels MimeNoContent [ChannelDTO] accept
getSystemChannels :: Accept accept
-> ExperimentId
-> NeptuneBackendRequest
     GetSystemChannels MimeNoContent [ChannelDTO] accept
getSystemChannels  Accept accept
_ (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetSystemChannels MimeNoContent [ChannelDTO] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/channels/system"]
    NeptuneBackendRequest
  GetSystemChannels MimeNoContent [ChannelDTO] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetSystemChannels MimeNoContent [ChannelDTO] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  GetSystemChannels MimeNoContent [ChannelDTO] accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetSystemChannels MimeNoContent [ChannelDTO] accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
experimentId)

data GetSystemChannels
-- | @*/*@
instance MimeType mtype => Produces GetSystemChannels mtype


-- *** getSystemMetricValues

-- | @GET \/api\/backend\/v1\/experiments\/{experimentId}\/system\/metrics\/{metricId}\/values@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getSystemMetricValues
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> MetricId -- ^ "metricId"
  -> NeptuneBackendRequest GetSystemMetricValues MimeNoContent [SystemMetricValues] accept
getSystemMetricValues :: Accept accept
-> ExperimentId
-> MetricId
-> NeptuneBackendRequest
     GetSystemMetricValues MimeNoContent [SystemMetricValues] accept
getSystemMetricValues  Accept accept
_ (ExperimentId Text
experimentId) (MetricId Text
metricId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetSystemMetricValues MimeNoContent [SystemMetricValues] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/experiments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
experimentId,ByteString
"/system/metrics/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
metricId,ByteString
"/values"]
    NeptuneBackendRequest
  GetSystemMetricValues MimeNoContent [SystemMetricValues] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetSystemMetricValues MimeNoContent [SystemMetricValues] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetSystemMetricValues
instance HasOptionalParam GetSystemMetricValues StartPoint where
  applyOptionalParam :: NeptuneBackendRequest GetSystemMetricValues contentType res accept
-> StartPoint
-> NeptuneBackendRequest
     GetSystemMetricValues contentType res accept
applyOptionalParam NeptuneBackendRequest GetSystemMetricValues contentType res accept
req (StartPoint Integer
xs) =
    NeptuneBackendRequest GetSystemMetricValues contentType res accept
req NeptuneBackendRequest GetSystemMetricValues contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetSystemMetricValues contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Integer) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"startPoint", Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
xs)
instance HasOptionalParam GetSystemMetricValues EndPoint where
  applyOptionalParam :: NeptuneBackendRequest GetSystemMetricValues contentType res accept
-> EndPoint
-> NeptuneBackendRequest
     GetSystemMetricValues contentType res accept
applyOptionalParam NeptuneBackendRequest GetSystemMetricValues contentType res accept
req (EndPoint Integer
xs) =
    NeptuneBackendRequest GetSystemMetricValues contentType res accept
req NeptuneBackendRequest GetSystemMetricValues contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetSystemMetricValues contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Integer) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"endPoint", Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
xs)
instance HasOptionalParam GetSystemMetricValues ItemCount where
  applyOptionalParam :: NeptuneBackendRequest GetSystemMetricValues contentType res accept
-> ItemCount
-> NeptuneBackendRequest
     GetSystemMetricValues contentType res accept
applyOptionalParam NeptuneBackendRequest GetSystemMetricValues contentType res accept
req (ItemCount Int
xs) =
    NeptuneBackendRequest GetSystemMetricValues contentType res accept
req NeptuneBackendRequest GetSystemMetricValues contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest
     GetSystemMetricValues contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Int) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"itemCount", Int -> Maybe Int
forall a. a -> Maybe a
Just Int
xs)
-- | @*/*@
instance MimeType mtype => Produces GetSystemMetricValues mtype


-- *** getSystemMetrics

-- | @GET \/api\/backend\/v1\/experiments\/{experimentId}\/system\/metrics@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getSystemMetrics
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest GetSystemMetrics MimeNoContent [SystemMetric] accept
getSystemMetrics :: Accept accept
-> ExperimentId
-> NeptuneBackendRequest
     GetSystemMetrics MimeNoContent [SystemMetric] accept
getSystemMetrics  Accept accept
_ (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetSystemMetrics MimeNoContent [SystemMetric] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/experiments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
experimentId,ByteString
"/system/metrics"]
    NeptuneBackendRequest
  GetSystemMetrics MimeNoContent [SystemMetric] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetSystemMetrics MimeNoContent [SystemMetric] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetSystemMetrics
-- | @*/*@
instance MimeType mtype => Produces GetSystemMetrics mtype


-- *** getSystemMetricsCSV

-- | @GET \/api\/backend\/v1\/experiments\/{experimentId}\/system\/metrics\/csv@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
getSystemMetricsCSV
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest GetSystemMetricsCSV MimeNoContent res accept
getSystemMetricsCSV :: Accept accept
-> ExperimentId
-> NeptuneBackendRequest
     GetSystemMetricsCSV MimeNoContent res accept
getSystemMetricsCSV  Accept accept
_ (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetSystemMetricsCSV MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/experiments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
experimentId,ByteString
"/system/metrics/csv"]
    NeptuneBackendRequest GetSystemMetricsCSV MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetSystemMetricsCSV MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetSystemMetricsCSV
instance HasOptionalParam GetSystemMetricsCSV Gzipped where
  applyOptionalParam :: NeptuneBackendRequest GetSystemMetricsCSV contentType res accept
-> Gzipped
-> NeptuneBackendRequest GetSystemMetricsCSV contentType res accept
applyOptionalParam NeptuneBackendRequest GetSystemMetricsCSV contentType res accept
req (Gzipped Bool
xs) =
    NeptuneBackendRequest GetSystemMetricsCSV contentType res accept
req NeptuneBackendRequest GetSystemMetricsCSV contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest GetSystemMetricsCSV contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Bool) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"gzipped", Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
xs)
-- | @*/*@
instance MimeType mtype => Produces GetSystemMetricsCSV mtype


-- *** getUpcomingInvoice

-- | @GET \/api\/backend\/v1\/payments\/{organizationIdentifier}\/invoices\/upcoming@
--
-- Pass-through to Stripe /v1/invoices/upcoming
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getUpcomingInvoice
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> NeptuneBackendRequest GetUpcomingInvoice MimeNoContent Text accept
getUpcomingInvoice :: Accept accept
-> OrganizationIdentifier
-> NeptuneBackendRequest
     GetUpcomingInvoice MimeNoContent Text accept
getUpcomingInvoice  Accept accept
_ (OrganizationIdentifier Text
organizationIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetUpcomingInvoice MimeNoContent Text accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/payments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/invoices/upcoming"]
    NeptuneBackendRequest GetUpcomingInvoice MimeNoContent Text accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetUpcomingInvoice MimeNoContent Text accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetUpcomingInvoice
-- | @*/*@
instance MimeType mtype => Produces GetUpcomingInvoice mtype


-- *** getUserAvatar

-- | @GET \/api\/backend\/v1\/users\/{username}\/avatar@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
getUserAvatar
  :: Accept accept -- ^ request accept ('MimeType')
  -> UsernameText -- ^ "username"
  -> NeptuneBackendRequest GetUserAvatar MimeNoContent res accept
getUserAvatar :: Accept accept
-> UsernameText
-> NeptuneBackendRequest GetUserAvatar MimeNoContent res accept
getUserAvatar  Accept accept
_ (UsernameText Text
username) =
  Method
-> [ByteString]
-> NeptuneBackendRequest GetUserAvatar MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/users/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
username,ByteString
"/avatar"]
    NeptuneBackendRequest GetUserAvatar MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest GetUserAvatar MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetUserAvatar
-- | @*/*@
instance MimeType mtype => Produces GetUserAvatar mtype


-- *** getUserProfile

-- | @GET \/api\/backend\/v1\/userProfile@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
getUserProfile
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest GetUserProfile MimeNoContent UserProfileDTO accept
getUserProfile :: Accept accept
-> NeptuneBackendRequest
     GetUserProfile MimeNoContent UserProfileDTO accept
getUserProfile  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetUserProfile MimeNoContent UserProfileDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/userProfile"]
    NeptuneBackendRequest
  GetUserProfile MimeNoContent UserProfileDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetUserProfile MimeNoContent UserProfileDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetUserProfile
-- | @*/*@
instance MimeType mtype => Produces GetUserProfile mtype


-- *** getUserProfileAvatar

-- | @GET \/api\/backend\/v1\/userProfile\/avatar@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
getUserProfileAvatar
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest GetUserProfileAvatar MimeNoContent res accept
getUserProfileAvatar :: Accept accept
-> NeptuneBackendRequest
     GetUserProfileAvatar MimeNoContent res accept
getUserProfileAvatar  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GetUserProfileAvatar MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/userProfile/avatar"]
    NeptuneBackendRequest GetUserProfileAvatar MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GetUserProfileAvatar MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GetUserProfileAvatar
-- | @*/*@
instance MimeType mtype => Produces GetUserProfileAvatar mtype


-- *** globalConfiguration0

-- | @GET \/api\/backend\/v1\/config@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
globalConfiguration0
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest GlobalConfiguration0 MimeNoContent GlobalConfiguration accept
globalConfiguration0 :: Accept accept
-> NeptuneBackendRequest
     GlobalConfiguration0 MimeNoContent GlobalConfiguration accept
globalConfiguration0  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     GlobalConfiguration0 MimeNoContent GlobalConfiguration accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/config"]
    NeptuneBackendRequest
  GlobalConfiguration0 MimeNoContent GlobalConfiguration accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     GlobalConfiguration0 MimeNoContent GlobalConfiguration accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data GlobalConfiguration0
-- | @*/*@
instance MimeType mtype => Produces GlobalConfiguration0 mtype


-- *** healthz

-- | @GET \/api\/backend\/healthz@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
healthz
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest Healthz MimeNoContent [ComponentStatus] accept
healthz :: Accept accept
-> NeptuneBackendRequest
     Healthz MimeNoContent [ComponentStatus] accept
healthz  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     Healthz MimeNoContent [ComponentStatus] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/healthz"]
    NeptuneBackendRequest
  Healthz MimeNoContent [ComponentStatus] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     Healthz MimeNoContent [ComponentStatus] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data Healthz
-- | @*/*@
instance MimeType mtype => Produces Healthz mtype


-- *** isOrganizationNameAvailable

-- | @GET \/api\/backend\/v1\/organizations2\/{organizationName}\/available@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
isOrganizationNameAvailable
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationName -- ^ "organizationName"
  -> NeptuneBackendRequest IsOrganizationNameAvailable MimeNoContent OrganizationNameAvailableDTO accept
isOrganizationNameAvailable :: Accept accept
-> OrganizationName
-> NeptuneBackendRequest
     IsOrganizationNameAvailable
     MimeNoContent
     OrganizationNameAvailableDTO
     accept
isOrganizationNameAvailable  Accept accept
_ (OrganizationName Text
organizationName) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     IsOrganizationNameAvailable
     MimeNoContent
     OrganizationNameAvailableDTO
     accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationName,ByteString
"/available"]
    NeptuneBackendRequest
  IsOrganizationNameAvailable
  MimeNoContent
  OrganizationNameAvailableDTO
  accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     IsOrganizationNameAvailable
     MimeNoContent
     OrganizationNameAvailableDTO
     accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data IsOrganizationNameAvailable
-- | @*/*@
instance MimeType mtype => Produces IsOrganizationNameAvailable mtype


-- *** leaveProject

-- | @POST \/api\/backend\/v1\/projects\/leave@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
leaveProject
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectIdentifier -- ^ "projectIdentifier"
  -> NeptuneBackendRequest LeaveProject MimeNoContent res accept
leaveProject :: Accept accept
-> ProjectIdentifier
-> NeptuneBackendRequest LeaveProject MimeNoContent res accept
leaveProject  Accept accept
_ (ProjectIdentifier Text
projectIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest LeaveProject MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/projects/leave"]
    NeptuneBackendRequest LeaveProject MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest LeaveProject MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest LeaveProject MimeNoContent res accept
-> [QueryItem]
-> NeptuneBackendRequest LeaveProject MimeNoContent res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectIdentifier)

data LeaveProject
-- | @*/*@
instance MimeType mtype => Produces LeaveProject mtype


-- *** listMembers

-- | @GET \/api\/backend\/v1\/projects\/users@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
listMembers
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest ListMembers MimeNoContent [UserListDTO] accept
listMembers :: Accept accept
-> NeptuneBackendRequest
     ListMembers MimeNoContent [UserListDTO] accept
listMembers  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ListMembers MimeNoContent [UserListDTO] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/projects/users"]
    NeptuneBackendRequest
  ListMembers MimeNoContent [UserListDTO] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     ListMembers MimeNoContent [UserListDTO] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data ListMembers
instance HasOptionalParam ListMembers OrganizationIdentifier where
  applyOptionalParam :: NeptuneBackendRequest ListMembers contentType res accept
-> OrganizationIdentifier
-> NeptuneBackendRequest ListMembers contentType res accept
applyOptionalParam NeptuneBackendRequest ListMembers contentType res accept
req (OrganizationIdentifier Text
xs) =
    NeptuneBackendRequest ListMembers contentType res accept
req NeptuneBackendRequest ListMembers contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListMembers contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"organizationIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam ListMembers ProjectIdentifier where
  applyOptionalParam :: NeptuneBackendRequest ListMembers contentType res accept
-> ProjectIdentifier
-> NeptuneBackendRequest ListMembers contentType res accept
applyOptionalParam NeptuneBackendRequest ListMembers contentType res accept
req (ProjectIdentifier Text
xs) =
    NeptuneBackendRequest ListMembers contentType res accept
req NeptuneBackendRequest ListMembers contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListMembers contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam ListMembers UsernamePrefix where
  applyOptionalParam :: NeptuneBackendRequest ListMembers contentType res accept
-> UsernamePrefix
-> NeptuneBackendRequest ListMembers contentType res accept
applyOptionalParam NeptuneBackendRequest ListMembers contentType res accept
req (UsernamePrefix Text
xs) =
    NeptuneBackendRequest ListMembers contentType res accept
req NeptuneBackendRequest ListMembers contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListMembers contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"usernamePrefix", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam ListMembers Offset where
  applyOptionalParam :: NeptuneBackendRequest ListMembers contentType res accept
-> Offset
-> NeptuneBackendRequest ListMembers contentType res accept
applyOptionalParam NeptuneBackendRequest ListMembers contentType res accept
req (Offset Int
xs) =
    NeptuneBackendRequest ListMembers contentType res accept
req NeptuneBackendRequest ListMembers contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListMembers contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Int) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"offset", Int -> Maybe Int
forall a. a -> Maybe a
Just Int
xs)
instance HasOptionalParam ListMembers Limit where
  applyOptionalParam :: NeptuneBackendRequest ListMembers contentType res accept
-> Limit
-> NeptuneBackendRequest ListMembers contentType res accept
applyOptionalParam NeptuneBackendRequest ListMembers contentType res accept
req (Limit Int
xs) =
    NeptuneBackendRequest ListMembers contentType res accept
req NeptuneBackendRequest ListMembers contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListMembers contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Int) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"limit", Int -> Maybe Int
forall a. a -> Maybe a
Just Int
xs)
-- | @*/*@
instance MimeType mtype => Produces ListMembers mtype


-- *** listOrganizationMembers

-- | @GET \/api\/backend\/v1\/organizations2\/{organizationIdentifier}\/members@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
listOrganizationMembers
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> NeptuneBackendRequest ListOrganizationMembers MimeNoContent [OrganizationMemberDTO] accept
listOrganizationMembers :: Accept accept
-> OrganizationIdentifier
-> NeptuneBackendRequest
     ListOrganizationMembers
     MimeNoContent
     [OrganizationMemberDTO]
     accept
listOrganizationMembers  Accept accept
_ (OrganizationIdentifier Text
organizationIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ListOrganizationMembers
     MimeNoContent
     [OrganizationMemberDTO]
     accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/members"]
    NeptuneBackendRequest
  ListOrganizationMembers
  MimeNoContent
  [OrganizationMemberDTO]
  accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     ListOrganizationMembers
     MimeNoContent
     [OrganizationMemberDTO]
     accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data ListOrganizationMembers
-- | @*/*@
instance MimeType mtype => Produces ListOrganizationMembers mtype


-- *** listOrganizations

-- | @GET \/api\/backend\/v1\/myOrganizations@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
listOrganizations
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest ListOrganizations MimeNoContent [OrganizationWithRoleDTO] accept
listOrganizations :: Accept accept
-> NeptuneBackendRequest
     ListOrganizations MimeNoContent [OrganizationWithRoleDTO] accept
listOrganizations  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ListOrganizations MimeNoContent [OrganizationWithRoleDTO] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/myOrganizations"]
    NeptuneBackendRequest
  ListOrganizations MimeNoContent [OrganizationWithRoleDTO] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     ListOrganizations MimeNoContent [OrganizationWithRoleDTO] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data ListOrganizations
-- | @*/*@
instance MimeType mtype => Produces ListOrganizations mtype


-- *** listProjectChartSets

-- | @GET \/api\/backend\/v1\/chartSets@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
listProjectChartSets
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectId -- ^ "projectId"
  -> NeptuneBackendRequest ListProjectChartSets MimeNoContent [ChartSet] accept
listProjectChartSets :: Accept accept
-> ProjectId
-> NeptuneBackendRequest
     ListProjectChartSets MimeNoContent [ChartSet] accept
listProjectChartSets  Accept accept
_ (ProjectId Text
projectId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ListProjectChartSets MimeNoContent [ChartSet] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/chartSets"]
    NeptuneBackendRequest
  ListProjectChartSets MimeNoContent [ChartSet] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     ListProjectChartSets MimeNoContent [ChartSet] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  ListProjectChartSets MimeNoContent [ChartSet] accept
-> [QueryItem]
-> NeptuneBackendRequest
     ListProjectChartSets MimeNoContent [ChartSet] accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectId)

data ListProjectChartSets
-- | @*/*@
instance MimeType mtype => Produces ListProjectChartSets mtype


-- *** listProjectMembers

-- | @GET \/api\/backend\/v1\/projects\/membersOf@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
listProjectMembers
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectIdentifier -- ^ "projectIdentifier"
  -> NeptuneBackendRequest ListProjectMembers MimeNoContent [ProjectMemberDTO] accept
listProjectMembers :: Accept accept
-> ProjectIdentifier
-> NeptuneBackendRequest
     ListProjectMembers MimeNoContent [ProjectMemberDTO] accept
listProjectMembers  Accept accept
_ (ProjectIdentifier Text
projectIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ListProjectMembers MimeNoContent [ProjectMemberDTO] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/projects/membersOf"]
    NeptuneBackendRequest
  ListProjectMembers MimeNoContent [ProjectMemberDTO] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     ListProjectMembers MimeNoContent [ProjectMemberDTO] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  ListProjectMembers MimeNoContent [ProjectMemberDTO] accept
-> [QueryItem]
-> NeptuneBackendRequest
     ListProjectMembers MimeNoContent [ProjectMemberDTO] accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectIdentifier)

data ListProjectMembers
-- | @*/*@
instance MimeType mtype => Produces ListProjectMembers mtype


-- *** listProjects

-- | @GET \/api\/backend\/v1\/projects@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
listProjects
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest ListProjects MimeNoContent ProjectListDTO accept
listProjects :: Accept accept
-> NeptuneBackendRequest
     ListProjects MimeNoContent ProjectListDTO accept
listProjects  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ListProjects MimeNoContent ProjectListDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/projects"]
    NeptuneBackendRequest
  ListProjects MimeNoContent ProjectListDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     ListProjects MimeNoContent ProjectListDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data ListProjects
instance HasOptionalParam ListProjects OrganizationIdentifier where
  applyOptionalParam :: NeptuneBackendRequest ListProjects contentType res accept
-> OrganizationIdentifier
-> NeptuneBackendRequest ListProjects contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjects contentType res accept
req (OrganizationIdentifier Text
xs) =
    NeptuneBackendRequest ListProjects contentType res accept
req NeptuneBackendRequest ListProjects contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjects contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"organizationIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam ListProjects ProjectKey where
  applyOptionalParam :: NeptuneBackendRequest ListProjects contentType res accept
-> ProjectKey
-> NeptuneBackendRequest ListProjects contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjects contentType res accept
req (ProjectKey Text
xs) =
    NeptuneBackendRequest ListProjects contentType res accept
req NeptuneBackendRequest ListProjects contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjects contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectKey", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam ListProjects SearchTerm where
  applyOptionalParam :: NeptuneBackendRequest ListProjects contentType res accept
-> SearchTerm
-> NeptuneBackendRequest ListProjects contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjects contentType res accept
req (SearchTerm Text
xs) =
    NeptuneBackendRequest ListProjects contentType res accept
req NeptuneBackendRequest ListProjects contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjects contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"searchTerm", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam ListProjects Visibility where
  applyOptionalParam :: NeptuneBackendRequest ListProjects contentType res accept
-> Visibility
-> NeptuneBackendRequest ListProjects contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjects contentType res accept
req (Visibility Text
xs) =
    NeptuneBackendRequest ListProjects contentType res accept
req NeptuneBackendRequest ListProjects contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjects contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"visibility", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam ListProjects ViewedUsername where
  applyOptionalParam :: NeptuneBackendRequest ListProjects contentType res accept
-> ViewedUsername
-> NeptuneBackendRequest ListProjects contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjects contentType res accept
req (ViewedUsername Text
xs) =
    NeptuneBackendRequest ListProjects contentType res accept
req NeptuneBackendRequest ListProjects contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjects contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"viewedUsername", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam ListProjects UserRelation where
  applyOptionalParam :: NeptuneBackendRequest ListProjects contentType res accept
-> UserRelation
-> NeptuneBackendRequest ListProjects contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjects contentType res accept
req (UserRelation Text
xs) =
    NeptuneBackendRequest ListProjects contentType res accept
req NeptuneBackendRequest ListProjects contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjects contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"userRelation", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam ListProjects OrgRelation where
  applyOptionalParam :: NeptuneBackendRequest ListProjects contentType res accept
-> OrgRelation
-> NeptuneBackendRequest ListProjects contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjects contentType res accept
req (OrgRelation [Text]
xs) =
    NeptuneBackendRequest ListProjects contentType res accept
req NeptuneBackendRequest ListProjects contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjects contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` CollectionFormat -> (Method, Maybe [Text]) -> [QueryItem]
forall a.
ToHttpApiData a =>
CollectionFormat -> (Method, Maybe [a]) -> [QueryItem]
toQueryColl CollectionFormat
MultiParamArray (Method
"orgRelation", [Text] -> Maybe [Text]
forall a. a -> Maybe a
Just [Text]
xs)
instance HasOptionalParam ListProjects SortBy where
  applyOptionalParam :: NeptuneBackendRequest ListProjects contentType res accept
-> SortBy
-> NeptuneBackendRequest ListProjects contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjects contentType res accept
req (SortBy [Text]
xs) =
    NeptuneBackendRequest ListProjects contentType res accept
req NeptuneBackendRequest ListProjects contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjects contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` CollectionFormat -> (Method, Maybe [Text]) -> [QueryItem]
forall a.
ToHttpApiData a =>
CollectionFormat -> (Method, Maybe [a]) -> [QueryItem]
toQueryColl CollectionFormat
MultiParamArray (Method
"sortBy", [Text] -> Maybe [Text]
forall a. a -> Maybe a
Just [Text]
xs)
instance HasOptionalParam ListProjects SortDirection where
  applyOptionalParam :: NeptuneBackendRequest ListProjects contentType res accept
-> SortDirection
-> NeptuneBackendRequest ListProjects contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjects contentType res accept
req (SortDirection [Text]
xs) =
    NeptuneBackendRequest ListProjects contentType res accept
req NeptuneBackendRequest ListProjects contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjects contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` CollectionFormat -> (Method, Maybe [Text]) -> [QueryItem]
forall a.
ToHttpApiData a =>
CollectionFormat -> (Method, Maybe [a]) -> [QueryItem]
toQueryColl CollectionFormat
MultiParamArray (Method
"sortDirection", [Text] -> Maybe [Text]
forall a. a -> Maybe a
Just [Text]
xs)
instance HasOptionalParam ListProjects Offset where
  applyOptionalParam :: NeptuneBackendRequest ListProjects contentType res accept
-> Offset
-> NeptuneBackendRequest ListProjects contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjects contentType res accept
req (Offset Int
xs) =
    NeptuneBackendRequest ListProjects contentType res accept
req NeptuneBackendRequest ListProjects contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjects contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Int) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"offset", Int -> Maybe Int
forall a. a -> Maybe a
Just Int
xs)
instance HasOptionalParam ListProjects Limit where
  applyOptionalParam :: NeptuneBackendRequest ListProjects contentType res accept
-> Limit
-> NeptuneBackendRequest ListProjects contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjects contentType res accept
req (Limit Int
xs) =
    NeptuneBackendRequest ListProjects contentType res accept
req NeptuneBackendRequest ListProjects contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjects contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Int) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"limit", Int -> Maybe Int
forall a. a -> Maybe a
Just Int
xs)
-- | @*/*@
instance MimeType mtype => Produces ListProjects mtype


-- *** listProjectsMembers

-- | @GET \/api\/backend\/v1\/projects\/members@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
listProjectsMembers
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectIdentifierText -- ^ "projectIdentifier"
  -> NeptuneBackendRequest ListProjectsMembers MimeNoContent [ProjectMembersDTO] accept
listProjectsMembers :: Accept accept
-> ProjectIdentifierText
-> NeptuneBackendRequest
     ListProjectsMembers MimeNoContent [ProjectMembersDTO] accept
listProjectsMembers  Accept accept
_ (ProjectIdentifierText [Text]
projectIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ListProjectsMembers MimeNoContent [ProjectMembersDTO] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/projects/members"]
    NeptuneBackendRequest
  ListProjectsMembers MimeNoContent [ProjectMembersDTO] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     ListProjectsMembers MimeNoContent [ProjectMembersDTO] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  ListProjectsMembers MimeNoContent [ProjectMembersDTO] accept
-> [QueryItem]
-> NeptuneBackendRequest
     ListProjectsMembers MimeNoContent [ProjectMembersDTO] accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` CollectionFormat -> (Method, Maybe [Text]) -> [QueryItem]
forall a.
ToHttpApiData a =>
CollectionFormat -> (Method, Maybe [a]) -> [QueryItem]
toQueryColl CollectionFormat
MultiParamArray (Method
"projectIdentifier", [Text] -> Maybe [Text]
forall a. a -> Maybe a
Just [Text]
projectIdentifier)

data ListProjectsMembers
instance HasOptionalParam ListProjectsMembers IncludeInvitations where
  applyOptionalParam :: NeptuneBackendRequest ListProjectsMembers contentType res accept
-> IncludeInvitations
-> NeptuneBackendRequest ListProjectsMembers contentType res accept
applyOptionalParam NeptuneBackendRequest ListProjectsMembers contentType res accept
req (IncludeInvitations Bool
xs) =
    NeptuneBackendRequest ListProjectsMembers contentType res accept
req NeptuneBackendRequest ListProjectsMembers contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest ListProjectsMembers contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Bool) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"includeInvitations", Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
xs)
-- | @*/*@
instance MimeType mtype => Produces ListProjectsMembers mtype


-- *** listUsers

-- | @GET \/api\/backend\/v1\/users@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
listUsers
  :: Accept accept -- ^ request accept ('MimeType')
  -> Username -- ^ "username"
  -> NeptuneBackendRequest ListUsers MimeNoContent [PublicUserProfileDTO] accept
listUsers :: Accept accept
-> Username
-> NeptuneBackendRequest
     ListUsers MimeNoContent [PublicUserProfileDTO] accept
listUsers  Accept accept
_ (Username [Text]
username) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ListUsers MimeNoContent [PublicUserProfileDTO] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/users"]
    NeptuneBackendRequest
  ListUsers MimeNoContent [PublicUserProfileDTO] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     ListUsers MimeNoContent [PublicUserProfileDTO] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  ListUsers MimeNoContent [PublicUserProfileDTO] accept
-> [QueryItem]
-> NeptuneBackendRequest
     ListUsers MimeNoContent [PublicUserProfileDTO] accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` CollectionFormat -> (Method, Maybe [Text]) -> [QueryItem]
forall a.
ToHttpApiData a =>
CollectionFormat -> (Method, Maybe [a]) -> [QueryItem]
toQueryColl CollectionFormat
MultiParamArray (Method
"username", [Text] -> Maybe [Text]
forall a. a -> Maybe a
Just [Text]
username)

data ListUsers
-- | @*/*@
instance MimeType mtype => Produces ListUsers mtype


-- *** markExperimentCompleted

-- | @POST \/api\/leaderboard\/v1\/experiments\/markCompleted@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
markExperimentCompleted
  :: (Consumes MarkExperimentCompleted contentType, MimeRender contentType CompletedExperimentParams)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> CompletedExperimentParams -- ^ "completedExperimentParams"
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest MarkExperimentCompleted contentType res accept
markExperimentCompleted :: ContentType contentType
-> Accept accept
-> CompletedExperimentParams
-> ExperimentId
-> NeptuneBackendRequest
     MarkExperimentCompleted contentType res accept
markExperimentCompleted ContentType contentType
_  Accept accept
_ CompletedExperimentParams
completedExperimentParams (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     MarkExperimentCompleted contentType res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/experiments/markCompleted"]
    NeptuneBackendRequest
  MarkExperimentCompleted contentType res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     MarkExperimentCompleted contentType res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  MarkExperimentCompleted contentType res accept
-> CompletedExperimentParams
-> NeptuneBackendRequest
     MarkExperimentCompleted contentType res accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` CompletedExperimentParams
completedExperimentParams
    NeptuneBackendRequest
  MarkExperimentCompleted contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest
     MarkExperimentCompleted contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
experimentId)

data MarkExperimentCompleted
instance HasBodyParam MarkExperimentCompleted CompletedExperimentParams

-- | @*/*@
instance MimeType mtype => Consumes MarkExperimentCompleted mtype

-- | @*/*@
instance MimeType mtype => Produces MarkExperimentCompleted mtype


-- *** pingExperiment

-- | @POST \/api\/leaderboard\/v1\/experiments\/ping@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
pingExperiment
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest PingExperiment MimeNoContent res accept
pingExperiment :: Accept accept
-> ExperimentId
-> NeptuneBackendRequest PingExperiment MimeNoContent res accept
pingExperiment  Accept accept
_ (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest PingExperiment MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/experiments/ping"]
    NeptuneBackendRequest PingExperiment MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest PingExperiment MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest PingExperiment MimeNoContent res accept
-> [QueryItem]
-> NeptuneBackendRequest PingExperiment MimeNoContent res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
experimentId)

data PingExperiment
-- | @*/*@
instance MimeType mtype => Produces PingExperiment mtype


-- *** postChannelValues

-- | @POST \/api\/leaderboard\/v1\/channels\/values@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
postChannelValues
  :: (Consumes PostChannelValues contentType, MimeRender contentType ChannelsValues)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ChannelsValues -- ^ "channelsValues"
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest PostChannelValues contentType [BatchChannelValueErrorDTO] accept
postChannelValues :: ContentType contentType
-> Accept accept
-> ChannelsValues
-> ExperimentId
-> NeptuneBackendRequest
     PostChannelValues contentType [BatchChannelValueErrorDTO] accept
postChannelValues ContentType contentType
_  Accept accept
_ ChannelsValues
channelsValues (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     PostChannelValues contentType [BatchChannelValueErrorDTO] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/channels/values"]
    NeptuneBackendRequest
  PostChannelValues contentType [BatchChannelValueErrorDTO] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     PostChannelValues contentType [BatchChannelValueErrorDTO] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  PostChannelValues contentType [BatchChannelValueErrorDTO] accept
-> ChannelsValues
-> NeptuneBackendRequest
     PostChannelValues contentType [BatchChannelValueErrorDTO] accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ChannelsValues
channelsValues
    NeptuneBackendRequest
  PostChannelValues contentType [BatchChannelValueErrorDTO] accept
-> [QueryItem]
-> NeptuneBackendRequest
     PostChannelValues contentType [BatchChannelValueErrorDTO] accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
experimentId)

data PostChannelValues
instance HasBodyParam PostChannelValues ChannelsValues

-- | @*/*@
instance MimeType mtype => Consumes PostChannelValues mtype

-- | @*/*@
instance MimeType mtype => Produces PostChannelValues mtype


-- *** postSystemMetricValues

-- | @POST \/api\/backend\/v1\/experiments\/{experimentId}\/system\/metrics\/values@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
postSystemMetricValues
  :: (Consumes PostSystemMetricValues contentType, MimeRender contentType MetricValues)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> MetricValues -- ^ "metricValues"
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest PostSystemMetricValues contentType res accept
postSystemMetricValues :: ContentType contentType
-> Accept accept
-> MetricValues
-> ExperimentId
-> NeptuneBackendRequest
     PostSystemMetricValues contentType res accept
postSystemMetricValues ContentType contentType
_  Accept accept
_ MetricValues
metricValues (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     PostSystemMetricValues contentType res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/experiments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
experimentId,ByteString
"/system/metrics/values"]
    NeptuneBackendRequest PostSystemMetricValues contentType res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     PostSystemMetricValues contentType res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest PostSystemMetricValues contentType res accept
-> MetricValues
-> NeptuneBackendRequest
     PostSystemMetricValues contentType res accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` MetricValues
metricValues

data PostSystemMetricValues
instance HasBodyParam PostSystemMetricValues MetricValues

-- | @*/*@
instance MimeType mtype => Consumes PostSystemMetricValues mtype

-- | @*/*@
instance MimeType mtype => Produces PostSystemMetricValues mtype


-- *** prepareForDownload

-- | @POST \/api\/leaderboard\/v1\/storage\/legacy\/downloadRequest@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
prepareForDownload
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentIdentity -- ^ "experimentIdentity"
  -> Resource -- ^ "resource"
  -> Path -- ^ "path"
  -> NeptuneBackendRequest PrepareForDownload MimeNoContent DownloadPrepareRequestDTO accept
prepareForDownload :: Accept accept
-> ExperimentIdentity
-> Resource
-> Path
-> NeptuneBackendRequest
     PrepareForDownload MimeNoContent DownloadPrepareRequestDTO accept
prepareForDownload  Accept accept
_ (ExperimentIdentity Text
experimentIdentity) (Resource Text
resource) (Path Text
path) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     PrepareForDownload MimeNoContent DownloadPrepareRequestDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/storage/legacy/downloadRequest"]
    NeptuneBackendRequest
  PrepareForDownload MimeNoContent DownloadPrepareRequestDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     PrepareForDownload MimeNoContent DownloadPrepareRequestDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  PrepareForDownload MimeNoContent DownloadPrepareRequestDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     PrepareForDownload MimeNoContent DownloadPrepareRequestDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentIdentity", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
experimentIdentity)
    NeptuneBackendRequest
  PrepareForDownload MimeNoContent DownloadPrepareRequestDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     PrepareForDownload MimeNoContent DownloadPrepareRequestDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"resource", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
resource)
    NeptuneBackendRequest
  PrepareForDownload MimeNoContent DownloadPrepareRequestDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     PrepareForDownload MimeNoContent DownloadPrepareRequestDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"path", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
path)

data PrepareForDownload
-- | @*/*@
instance MimeType mtype => Produces PrepareForDownload mtype


-- *** resetChannel

-- | @DELETE \/api\/leaderboard\/v1\/channels\/{id}\/values@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
resetChannel
  :: Accept accept -- ^ request accept ('MimeType')
  -> Id -- ^ "id"
  -> NeptuneBackendRequest ResetChannel MimeNoContent res accept
resetChannel :: Accept accept
-> Id
-> NeptuneBackendRequest ResetChannel MimeNoContent res accept
resetChannel  Accept accept
_ (Id Text
id) =
  Method
-> [ByteString]
-> NeptuneBackendRequest ResetChannel MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/leaderboard/v1/channels/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
id,ByteString
"/values"]
    NeptuneBackendRequest ResetChannel MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest ResetChannel MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data ResetChannel
-- | @*/*@
instance MimeType mtype => Produces ResetChannel mtype


-- *** restoreExperiments

-- | @POST \/api\/leaderboard\/v1\/experiments\/trash\/restore@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
restoreExperiments
  :: (Consumes RestoreExperiments contentType, MimeRender contentType ExperimentIds)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ExperimentIds -- ^ "experimentIds"
  -> NeptuneBackendRequest RestoreExperiments contentType [BatchExperimentUpdateResult] accept
restoreExperiments :: ContentType contentType
-> Accept accept
-> ExperimentIds
-> NeptuneBackendRequest
     RestoreExperiments contentType [BatchExperimentUpdateResult] accept
restoreExperiments ContentType contentType
_  Accept accept
_ ExperimentIds
experimentIds =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     RestoreExperiments contentType [BatchExperimentUpdateResult] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/experiments/trash/restore"]
    NeptuneBackendRequest
  RestoreExperiments contentType [BatchExperimentUpdateResult] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     RestoreExperiments contentType [BatchExperimentUpdateResult] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  RestoreExperiments contentType [BatchExperimentUpdateResult] accept
-> ExperimentIds
-> NeptuneBackendRequest
     RestoreExperiments contentType [BatchExperimentUpdateResult] accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ExperimentIds
experimentIds

data RestoreExperiments
instance HasBodyParam RestoreExperiments ExperimentIds

-- | @*/*@
instance MimeType mtype => Consumes RestoreExperiments mtype

-- | @*/*@
instance MimeType mtype => Produces RestoreExperiments mtype


-- *** revokeApiToken

-- | @DELETE \/api\/backend\/v1\/authorization\/api-token@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
revokeApiToken
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest RevokeApiToken MimeNoContent res accept
revokeApiToken :: Accept accept
-> NeptuneBackendRequest RevokeApiToken MimeNoContent res accept
revokeApiToken  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest RevokeApiToken MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/backend/v1/authorization/api-token"]
    NeptuneBackendRequest RevokeApiToken MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest RevokeApiToken MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data RevokeApiToken
-- | @*/*@
instance MimeType mtype => Produces RevokeApiToken mtype


-- *** revokeOrganizationInvitation

-- | @DELETE \/api\/backend\/v1\/invitations\/organization\/{invitationId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
revokeOrganizationInvitation
  :: Accept accept -- ^ request accept ('MimeType')
  -> InvitationId -- ^ "invitationId"
  -> NeptuneBackendRequest RevokeOrganizationInvitation MimeNoContent res accept
revokeOrganizationInvitation :: Accept accept
-> InvitationId
-> NeptuneBackendRequest
     RevokeOrganizationInvitation MimeNoContent res accept
revokeOrganizationInvitation  Accept accept
_ (InvitationId Text
invitationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     RevokeOrganizationInvitation MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/backend/v1/invitations/organization/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
invitationId]
    NeptuneBackendRequest
  RevokeOrganizationInvitation MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     RevokeOrganizationInvitation MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data RevokeOrganizationInvitation
-- | @*/*@
instance MimeType mtype => Produces RevokeOrganizationInvitation mtype


-- *** revokeProjectInvitation

-- | @DELETE \/api\/backend\/v1\/invitations\/project\/{invitationId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
revokeProjectInvitation
  :: Accept accept -- ^ request accept ('MimeType')
  -> InvitationId -- ^ "invitationId"
  -> NeptuneBackendRequest RevokeProjectInvitation MimeNoContent res accept
revokeProjectInvitation :: Accept accept
-> InvitationId
-> NeptuneBackendRequest
     RevokeProjectInvitation MimeNoContent res accept
revokeProjectInvitation  Accept accept
_ (InvitationId Text
invitationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     RevokeProjectInvitation MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"DELETE" [ByteString
"/api/backend/v1/invitations/project/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
invitationId]
    NeptuneBackendRequest
  RevokeProjectInvitation MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     RevokeProjectInvitation MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data RevokeProjectInvitation
-- | @*/*@
instance MimeType mtype => Produces RevokeProjectInvitation mtype


-- *** sendQuestionnaire

-- | @PUT \/api\/backend\/v1\/reservations\/{organizationName}\/questionnaire@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
sendQuestionnaire
  :: (Consumes SendQuestionnaire contentType, MimeRender contentType QuestionnaireDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> QuestionnaireDTO -- ^ "questionnaireAnswers"
  -> OrganizationName -- ^ "organizationName"
  -> NeptuneBackendRequest SendQuestionnaire contentType res accept
sendQuestionnaire :: ContentType contentType
-> Accept accept
-> QuestionnaireDTO
-> OrganizationName
-> NeptuneBackendRequest SendQuestionnaire contentType res accept
sendQuestionnaire ContentType contentType
_  Accept accept
_ QuestionnaireDTO
questionnaireAnswers (OrganizationName Text
organizationName) =
  Method
-> [ByteString]
-> NeptuneBackendRequest SendQuestionnaire contentType res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/reservations/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationName,ByteString
"/questionnaire"]
    NeptuneBackendRequest SendQuestionnaire contentType res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest SendQuestionnaire contentType res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest SendQuestionnaire contentType res accept
-> QuestionnaireDTO
-> NeptuneBackendRequest SendQuestionnaire contentType res accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` QuestionnaireDTO
questionnaireAnswers

data SendQuestionnaire
instance HasBodyParam SendQuestionnaire QuestionnaireDTO

-- | @*/*@
instance MimeType mtype => Consumes SendQuestionnaire mtype

-- | @*/*@
instance MimeType mtype => Produces SendQuestionnaire mtype


-- *** sendRegistrationSurvey

-- | @POST \/api\/backend\/v1\/login\/survey@
--
-- Processes the survey. Sending {} means that user declined survey and action is removed
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
sendRegistrationSurvey
  :: (Consumes SendRegistrationSurvey contentType, MimeRender contentType RegistrationSurveyDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> RegistrationSurveyDTO -- ^ "survey"
  -> NeptuneBackendRequest SendRegistrationSurvey contentType res accept
sendRegistrationSurvey :: ContentType contentType
-> Accept accept
-> RegistrationSurveyDTO
-> NeptuneBackendRequest
     SendRegistrationSurvey contentType res accept
sendRegistrationSurvey ContentType contentType
_  Accept accept
_ RegistrationSurveyDTO
survey =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     SendRegistrationSurvey contentType res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/login/survey"]
    NeptuneBackendRequest SendRegistrationSurvey contentType res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     SendRegistrationSurvey contentType res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest SendRegistrationSurvey contentType res accept
-> RegistrationSurveyDTO
-> NeptuneBackendRequest
     SendRegistrationSurvey contentType res accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` RegistrationSurveyDTO
survey

data SendRegistrationSurvey
instance HasBodyParam SendRegistrationSurvey RegistrationSurveyDTO

-- | @*/*@
instance MimeType mtype => Consumes SendRegistrationSurvey mtype

-- | @*/*@
instance MimeType mtype => Produces SendRegistrationSurvey mtype


-- *** setUsername

-- | @POST \/api\/backend\/v1\/login\/username@
--
--  Sets the username as per param. Can be called once, subsequent calls will result in 403 error. Setting to an invalid username will result in 400 error. Setting to an unavailable username will result in 409 error.
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
setUsername
  :: Accept accept -- ^ request accept ('MimeType')
  -> UsernameText -- ^ "username"
  -> NeptuneBackendRequest SetUsername MimeNoContent res accept
setUsername :: Accept accept
-> UsernameText
-> NeptuneBackendRequest SetUsername MimeNoContent res accept
setUsername  Accept accept
_ (UsernameText Text
username) =
  Method
-> [ByteString]
-> NeptuneBackendRequest SetUsername MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/login/username"]
    NeptuneBackendRequest SetUsername MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest SetUsername MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest SetUsername MimeNoContent res accept
-> [QueryItem]
-> NeptuneBackendRequest SetUsername MimeNoContent res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"username", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
username)

data SetUsername
-- | @*/*@
instance MimeType mtype => Produces SetUsername mtype


-- *** statusGet

-- | @GET \/api\/backend\/status@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
statusGet
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest StatusGet MimeNoContent A.Value accept
statusGet :: Accept accept
-> NeptuneBackendRequest StatusGet MimeNoContent Value accept
statusGet  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest StatusGet MimeNoContent Value accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/status"]
    NeptuneBackendRequest StatusGet MimeNoContent Value accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest StatusGet MimeNoContent Value accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data StatusGet
-- | @*/*@
instance MimeType mtype => Produces StatusGet mtype


-- *** storageUsage0

-- | @GET \/api\/backend\/v1\/storage\/usage@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
storageUsage0
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest StorageUsage0 MimeNoContent StorageUsage accept
storageUsage0 :: Accept accept
-> NeptuneBackendRequest
     StorageUsage0 MimeNoContent StorageUsage accept
storageUsage0  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     StorageUsage0 MimeNoContent StorageUsage accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/storage/usage"]
    NeptuneBackendRequest
  StorageUsage0 MimeNoContent StorageUsage accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     StorageUsage0 MimeNoContent StorageUsage accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data StorageUsage0
instance HasOptionalParam StorageUsage0 OrganizationIdentifier where
  applyOptionalParam :: NeptuneBackendRequest StorageUsage0 contentType res accept
-> OrganizationIdentifier
-> NeptuneBackendRequest StorageUsage0 contentType res accept
applyOptionalParam NeptuneBackendRequest StorageUsage0 contentType res accept
req (OrganizationIdentifier Text
xs) =
    NeptuneBackendRequest StorageUsage0 contentType res accept
req NeptuneBackendRequest StorageUsage0 contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest StorageUsage0 contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"organizationIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
instance HasOptionalParam StorageUsage0 ProjectIdentifier where
  applyOptionalParam :: NeptuneBackendRequest StorageUsage0 contentType res accept
-> ProjectIdentifier
-> NeptuneBackendRequest StorageUsage0 contentType res accept
applyOptionalParam NeptuneBackendRequest StorageUsage0 contentType res accept
req (ProjectIdentifier Text
xs) =
    NeptuneBackendRequest StorageUsage0 contentType res accept
req NeptuneBackendRequest StorageUsage0 contentType res accept
-> [QueryItem]
-> NeptuneBackendRequest StorageUsage0 contentType res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
xs)
-- | @*/*@
instance MimeType mtype => Produces StorageUsage0 mtype


-- *** synchronizeSubscription

-- | @PUT \/api\/backend\/v1\/payments\/{organizationName}\/synchronizeSubscription@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
synchronizeSubscription
  :: Accept accept -- ^ request accept ('MimeType')
  -> OrganizationName -- ^ "organizationName"
  -> NeptuneBackendRequest SynchronizeSubscription MimeNoContent res accept
synchronizeSubscription :: Accept accept
-> OrganizationName
-> NeptuneBackendRequest
     SynchronizeSubscription MimeNoContent res accept
synchronizeSubscription  Accept accept
_ (OrganizationName Text
organizationName) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     SynchronizeSubscription MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/payments/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationName,ByteString
"/synchronizeSubscription"]
    NeptuneBackendRequest
  SynchronizeSubscription MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     SynchronizeSubscription MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data SynchronizeSubscription
-- | @*/*@
instance MimeType mtype => Produces SynchronizeSubscription mtype


-- *** tagsGet

-- | @GET \/api\/leaderboard\/v1\/experiments\/tags@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
tagsGet
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectIdentifier -- ^ "projectIdentifier"
  -> NeptuneBackendRequest TagsGet MimeNoContent [Text] accept
tagsGet :: Accept accept
-> ProjectIdentifier
-> NeptuneBackendRequest TagsGet MimeNoContent [Text] accept
tagsGet  Accept accept
_ (ProjectIdentifier Text
projectIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest TagsGet MimeNoContent [Text] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/leaderboard/v1/experiments/tags"]
    NeptuneBackendRequest TagsGet MimeNoContent [Text] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest TagsGet MimeNoContent [Text] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest TagsGet MimeNoContent [Text] accept
-> [QueryItem]
-> NeptuneBackendRequest TagsGet MimeNoContent [Text] accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectIdentifier)

data TagsGet
-- | @*/*@
instance MimeType mtype => Produces TagsGet mtype


-- *** trashExperiments

-- | @POST \/api\/leaderboard\/v1\/experiments\/trash@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
trashExperiments
  :: (Consumes TrashExperiments contentType, MimeRender contentType ExperimentIds)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ExperimentIds -- ^ "experimentIds"
  -> NeptuneBackendRequest TrashExperiments contentType [BatchExperimentUpdateResult] accept
trashExperiments :: ContentType contentType
-> Accept accept
-> ExperimentIds
-> NeptuneBackendRequest
     TrashExperiments contentType [BatchExperimentUpdateResult] accept
trashExperiments ContentType contentType
_  Accept accept
_ ExperimentIds
experimentIds =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     TrashExperiments contentType [BatchExperimentUpdateResult] accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/experiments/trash"]
    NeptuneBackendRequest
  TrashExperiments contentType [BatchExperimentUpdateResult] accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     TrashExperiments contentType [BatchExperimentUpdateResult] accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  TrashExperiments contentType [BatchExperimentUpdateResult] accept
-> ExperimentIds
-> NeptuneBackendRequest
     TrashExperiments contentType [BatchExperimentUpdateResult] accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ExperimentIds
experimentIds

data TrashExperiments
instance HasBodyParam TrashExperiments ExperimentIds

-- | @*/*@
instance MimeType mtype => Consumes TrashExperiments mtype

-- | @*/*@
instance MimeType mtype => Produces TrashExperiments mtype


-- *** updateChart

-- | @PUT \/api\/backend\/v1\/chartSets\/{chartSetId}\/charts\/{chartId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateChart
  :: (Consumes UpdateChart contentType, MimeRender contentType ChartDefinition)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ChartDefinition -- ^ "chartToUpdate"
  -> ChartId -- ^ "chartId"
  -> ChartSetId -- ^ "chartSetId"
  -> NeptuneBackendRequest UpdateChart contentType Chart accept
updateChart :: ContentType contentType
-> Accept accept
-> ChartDefinition
-> ChartId
-> ChartSetId
-> NeptuneBackendRequest UpdateChart contentType Chart accept
updateChart ContentType contentType
_  Accept accept
_ ChartDefinition
chartToUpdate (ChartId Text
chartId) (ChartSetId Text
chartSetId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest UpdateChart contentType Chart accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/chartSets/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
chartSetId,ByteString
"/charts/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
chartId]
    NeptuneBackendRequest UpdateChart contentType Chart accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest UpdateChart contentType Chart accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest UpdateChart contentType Chart accept
-> ChartDefinition
-> NeptuneBackendRequest UpdateChart contentType Chart accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ChartDefinition
chartToUpdate

data UpdateChart
instance HasBodyParam UpdateChart ChartDefinition

-- | @*/*@
instance MimeType mtype => Consumes UpdateChart mtype

-- | @*/*@
instance MimeType mtype => Produces UpdateChart mtype


-- *** updateChartSet

-- | @PUT \/api\/backend\/v1\/chartSets\/{chartSetId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateChartSet
  :: (Consumes UpdateChartSet contentType, MimeRender contentType ChartSetParams)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ChartSetParams -- ^ "chartSetToUpdate"
  -> ChartSetId -- ^ "chartSetId"
  -> NeptuneBackendRequest UpdateChartSet contentType ChartSet accept
updateChartSet :: ContentType contentType
-> Accept accept
-> ChartSetParams
-> ChartSetId
-> NeptuneBackendRequest UpdateChartSet contentType ChartSet accept
updateChartSet ContentType contentType
_  Accept accept
_ ChartSetParams
chartSetToUpdate (ChartSetId Text
chartSetId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest UpdateChartSet contentType ChartSet accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/chartSets/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
chartSetId]
    NeptuneBackendRequest UpdateChartSet contentType ChartSet accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest UpdateChartSet contentType ChartSet accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest UpdateChartSet contentType ChartSet accept
-> ChartSetParams
-> NeptuneBackendRequest UpdateChartSet contentType ChartSet accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ChartSetParams
chartSetToUpdate

data UpdateChartSet
instance HasBodyParam UpdateChartSet ChartSetParams

-- | @*/*@
instance MimeType mtype => Consumes UpdateChartSet mtype

-- | @*/*@
instance MimeType mtype => Produces UpdateChartSet mtype


-- *** updateExperiment

-- | @PATCH \/api\/leaderboard\/v1\/experiments@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateExperiment
  :: (Consumes UpdateExperiment contentType, MimeRender contentType EditExperimentParams)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> EditExperimentParams -- ^ "editExperimentParams"
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest UpdateExperiment contentType Experiment accept
updateExperiment :: ContentType contentType
-> Accept accept
-> EditExperimentParams
-> ExperimentId
-> NeptuneBackendRequest
     UpdateExperiment contentType Experiment accept
updateExperiment ContentType contentType
_  Accept accept
_ EditExperimentParams
editExperimentParams (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateExperiment contentType Experiment accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PATCH" [ByteString
"/api/leaderboard/v1/experiments"]
    NeptuneBackendRequest
  UpdateExperiment contentType Experiment accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateExperiment contentType Experiment accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateExperiment contentType Experiment accept
-> EditExperimentParams
-> NeptuneBackendRequest
     UpdateExperiment contentType Experiment accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` EditExperimentParams
editExperimentParams
    NeptuneBackendRequest
  UpdateExperiment contentType Experiment accept
-> [QueryItem]
-> NeptuneBackendRequest
     UpdateExperiment contentType Experiment accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"experimentId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
experimentId)

data UpdateExperiment
instance HasBodyParam UpdateExperiment EditExperimentParams

-- | @*/*@
instance MimeType mtype => Consumes UpdateExperiment mtype

-- | @*/*@
instance MimeType mtype => Produces UpdateExperiment mtype


-- *** updateLastViewed

-- | @POST \/api\/backend\/v1\/projects\/updateLastViewed@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
updateLastViewed
  :: Accept accept -- ^ request accept ('MimeType')
  -> ProjectId -- ^ "projectId"
  -> NeptuneBackendRequest UpdateLastViewed MimeNoContent res accept
updateLastViewed :: Accept accept
-> ProjectId
-> NeptuneBackendRequest UpdateLastViewed MimeNoContent res accept
updateLastViewed  Accept accept
_ (ProjectId Text
projectId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest UpdateLastViewed MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/backend/v1/projects/updateLastViewed"]
    NeptuneBackendRequest UpdateLastViewed MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest UpdateLastViewed MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest UpdateLastViewed MimeNoContent res accept
-> [QueryItem]
-> NeptuneBackendRequest UpdateLastViewed MimeNoContent res accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectId", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectId)

data UpdateLastViewed
-- | @*/*@
instance MimeType mtype => Produces UpdateLastViewed mtype


-- *** updateOrganization

-- | @PUT \/api\/backend\/v1\/organizations2\/{organizationId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateOrganization
  :: (Consumes UpdateOrganization contentType, MimeRender contentType OrganizationUpdateDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> OrganizationUpdateDTO -- ^ "organizationToUpdate"
  -> OrganizationId -- ^ "organizationId"
  -> NeptuneBackendRequest UpdateOrganization contentType OrganizationDTO accept
updateOrganization :: ContentType contentType
-> Accept accept
-> OrganizationUpdateDTO
-> OrganizationId
-> NeptuneBackendRequest
     UpdateOrganization contentType OrganizationDTO accept
updateOrganization ContentType contentType
_  Accept accept
_ OrganizationUpdateDTO
organizationToUpdate (OrganizationId Text
organizationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateOrganization contentType OrganizationDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationId]
    NeptuneBackendRequest
  UpdateOrganization contentType OrganizationDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateOrganization contentType OrganizationDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateOrganization contentType OrganizationDTO accept
-> OrganizationUpdateDTO
-> NeptuneBackendRequest
     UpdateOrganization contentType OrganizationDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` OrganizationUpdateDTO
organizationToUpdate

data UpdateOrganization
instance HasBodyParam UpdateOrganization OrganizationUpdateDTO

-- | @*/*@
instance MimeType mtype => Consumes UpdateOrganization mtype

-- | @*/*@
instance MimeType mtype => Produces UpdateOrganization mtype


-- *** updateOrganizationAvatar

-- | @PUT \/api\/backend\/v1\/organizations2\/{organizationId}\/avatar@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateOrganizationAvatar
  :: (Consumes UpdateOrganizationAvatar MimeMultipartFormData)
  => Accept accept -- ^ request accept ('MimeType')
  -> AvatarFile -- ^ "avatarFile"
  -> OrganizationId -- ^ "organizationId"
  -> NeptuneBackendRequest UpdateOrganizationAvatar MimeMultipartFormData LinkDTO accept
updateOrganizationAvatar :: Accept accept
-> AvatarFile
-> OrganizationId
-> NeptuneBackendRequest
     UpdateOrganizationAvatar MimeMultipartFormData LinkDTO accept
updateOrganizationAvatar  Accept accept
_ (AvatarFile FilePath
avatarFile) (OrganizationId Text
organizationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateOrganizationAvatar MimeMultipartFormData LinkDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationId,ByteString
"/avatar"]
    NeptuneBackendRequest
  UpdateOrganizationAvatar MimeMultipartFormData LinkDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateOrganizationAvatar MimeMultipartFormData LinkDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateOrganizationAvatar MimeMultipartFormData LinkDTO accept
-> Part
-> NeptuneBackendRequest
     UpdateOrganizationAvatar MimeMultipartFormData LinkDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> Part -> NeptuneBackendRequest req contentType res accept
`_addMultiFormPart` Text -> FilePath -> Part
NH.partFileSource Text
"avatarFile" FilePath
avatarFile

data UpdateOrganizationAvatar

-- | @multipart/form-data@
instance Consumes UpdateOrganizationAvatar MimeMultipartFormData

-- | @*/*@
instance MimeType mtype => Produces UpdateOrganizationAvatar mtype


-- *** updateOrganizationInvitation

-- | @PUT \/api\/backend\/v1\/invitations\/organization\/{invitationId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateOrganizationInvitation
  :: (Consumes UpdateOrganizationInvitation contentType, MimeRender contentType OrganizationInvitationUpdateDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> OrganizationInvitationUpdateDTO -- ^ "update"
  -> InvitationId -- ^ "invitationId"
  -> NeptuneBackendRequest UpdateOrganizationInvitation contentType OrganizationInvitationDTO accept
updateOrganizationInvitation :: ContentType contentType
-> Accept accept
-> OrganizationInvitationUpdateDTO
-> InvitationId
-> NeptuneBackendRequest
     UpdateOrganizationInvitation
     contentType
     OrganizationInvitationDTO
     accept
updateOrganizationInvitation ContentType contentType
_  Accept accept
_ OrganizationInvitationUpdateDTO
update (InvitationId Text
invitationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateOrganizationInvitation
     contentType
     OrganizationInvitationDTO
     accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/invitations/organization/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
invitationId]
    NeptuneBackendRequest
  UpdateOrganizationInvitation
  contentType
  OrganizationInvitationDTO
  accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateOrganizationInvitation
     contentType
     OrganizationInvitationDTO
     accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateOrganizationInvitation
  contentType
  OrganizationInvitationDTO
  accept
-> OrganizationInvitationUpdateDTO
-> NeptuneBackendRequest
     UpdateOrganizationInvitation
     contentType
     OrganizationInvitationDTO
     accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` OrganizationInvitationUpdateDTO
update

data UpdateOrganizationInvitation
instance HasBodyParam UpdateOrganizationInvitation OrganizationInvitationUpdateDTO

-- | @*/*@
instance MimeType mtype => Consumes UpdateOrganizationInvitation mtype

-- | @*/*@
instance MimeType mtype => Produces UpdateOrganizationInvitation mtype


-- *** updateOrganizationMember

-- | @PATCH \/api\/backend\/v1\/organizations2\/{organizationIdentifier}\/members\/{userId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateOrganizationMember
  :: (Consumes UpdateOrganizationMember contentType, MimeRender contentType OrganizationMemberUpdateDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> OrganizationMemberUpdateDTO -- ^ "member"
  -> OrganizationIdentifier -- ^ "organizationIdentifier"
  -> UserId -- ^ "userId"
  -> NeptuneBackendRequest UpdateOrganizationMember contentType OrganizationMemberDTO accept
updateOrganizationMember :: ContentType contentType
-> Accept accept
-> OrganizationMemberUpdateDTO
-> OrganizationIdentifier
-> UserId
-> NeptuneBackendRequest
     UpdateOrganizationMember contentType OrganizationMemberDTO accept
updateOrganizationMember ContentType contentType
_  Accept accept
_ OrganizationMemberUpdateDTO
member (OrganizationIdentifier Text
organizationIdentifier) (UserId Text
userId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateOrganizationMember contentType OrganizationMemberDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PATCH" [ByteString
"/api/backend/v1/organizations2/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
organizationIdentifier,ByteString
"/members/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
userId]
    NeptuneBackendRequest
  UpdateOrganizationMember contentType OrganizationMemberDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateOrganizationMember contentType OrganizationMemberDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateOrganizationMember contentType OrganizationMemberDTO accept
-> OrganizationMemberUpdateDTO
-> NeptuneBackendRequest
     UpdateOrganizationMember contentType OrganizationMemberDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` OrganizationMemberUpdateDTO
member

data UpdateOrganizationMember
instance HasBodyParam UpdateOrganizationMember OrganizationMemberUpdateDTO

-- | @*/*@
instance MimeType mtype => Consumes UpdateOrganizationMember mtype

-- | @*/*@
instance MimeType mtype => Produces UpdateOrganizationMember mtype


-- *** updateProject

-- | @PUT \/api\/backend\/v1\/projects@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateProject
  :: (Consumes UpdateProject contentType, MimeRender contentType ProjectUpdateDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ProjectUpdateDTO -- ^ "projectToUpdate"
  -> ProjectIdentifier -- ^ "projectIdentifier"
  -> NeptuneBackendRequest UpdateProject contentType ProjectWithRoleDTO accept
updateProject :: ContentType contentType
-> Accept accept
-> ProjectUpdateDTO
-> ProjectIdentifier
-> NeptuneBackendRequest
     UpdateProject contentType ProjectWithRoleDTO accept
updateProject ContentType contentType
_  Accept accept
_ ProjectUpdateDTO
projectToUpdate (ProjectIdentifier Text
projectIdentifier) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateProject contentType ProjectWithRoleDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/projects"]
    NeptuneBackendRequest
  UpdateProject contentType ProjectWithRoleDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateProject contentType ProjectWithRoleDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateProject contentType ProjectWithRoleDTO accept
-> ProjectUpdateDTO
-> NeptuneBackendRequest
     UpdateProject contentType ProjectWithRoleDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ProjectUpdateDTO
projectToUpdate
    NeptuneBackendRequest
  UpdateProject contentType ProjectWithRoleDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     UpdateProject contentType ProjectWithRoleDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectIdentifier)

data UpdateProject
instance HasBodyParam UpdateProject ProjectUpdateDTO

-- | @*/*@
instance MimeType mtype => Consumes UpdateProject mtype

-- | @*/*@
instance MimeType mtype => Produces UpdateProject mtype


-- *** updateProjectAvatar

-- | @PUT \/api\/backend\/v1\/projects1\/{projectId}\/avatar@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateProjectAvatar
  :: (Consumes UpdateProjectAvatar MimeMultipartFormData)
  => Accept accept -- ^ request accept ('MimeType')
  -> AvatarFile -- ^ "avatarFile"
  -> ProjectId -- ^ "projectId"
  -> NeptuneBackendRequest UpdateProjectAvatar MimeMultipartFormData Link accept
updateProjectAvatar :: Accept accept
-> AvatarFile
-> ProjectId
-> NeptuneBackendRequest
     UpdateProjectAvatar MimeMultipartFormData Link accept
updateProjectAvatar  Accept accept
_ (AvatarFile FilePath
avatarFile) (ProjectId Text
projectId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateProjectAvatar MimeMultipartFormData Link accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/projects1/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
projectId,ByteString
"/avatar"]
    NeptuneBackendRequest
  UpdateProjectAvatar MimeMultipartFormData Link accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateProjectAvatar MimeMultipartFormData Link accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateProjectAvatar MimeMultipartFormData Link accept
-> Part
-> NeptuneBackendRequest
     UpdateProjectAvatar MimeMultipartFormData Link accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> Part -> NeptuneBackendRequest req contentType res accept
`_addMultiFormPart` Text -> FilePath -> Part
NH.partFileSource Text
"avatarFile" FilePath
avatarFile

data UpdateProjectAvatar

-- | @multipart/form-data@
instance Consumes UpdateProjectAvatar MimeMultipartFormData

-- | @*/*@
instance MimeType mtype => Produces UpdateProjectAvatar mtype


-- *** updateProjectBackground

-- | @PUT \/api\/backend\/v1\/projects1\/{projectId}\/background@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateProjectBackground
  :: (Consumes UpdateProjectBackground MimeMultipartFormData)
  => Accept accept -- ^ request accept ('MimeType')
  -> BackgroundFile -- ^ "backgroundFile"
  -> ProjectId -- ^ "projectId"
  -> NeptuneBackendRequest UpdateProjectBackground MimeMultipartFormData Link accept
updateProjectBackground :: Accept accept
-> BackgroundFile
-> ProjectId
-> NeptuneBackendRequest
     UpdateProjectBackground MimeMultipartFormData Link accept
updateProjectBackground  Accept accept
_ (BackgroundFile FilePath
backgroundFile) (ProjectId Text
projectId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateProjectBackground MimeMultipartFormData Link accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/projects1/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
projectId,ByteString
"/background"]
    NeptuneBackendRequest
  UpdateProjectBackground MimeMultipartFormData Link accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateProjectBackground MimeMultipartFormData Link accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateProjectBackground MimeMultipartFormData Link accept
-> Part
-> NeptuneBackendRequest
     UpdateProjectBackground MimeMultipartFormData Link accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> Part -> NeptuneBackendRequest req contentType res accept
`_addMultiFormPart` Text -> FilePath -> Part
NH.partFileSource Text
"backgroundFile" FilePath
backgroundFile

data UpdateProjectBackground

-- | @multipart/form-data@
instance Consumes UpdateProjectBackground MimeMultipartFormData

-- | @*/*@
instance MimeType mtype => Produces UpdateProjectBackground mtype


-- *** updateProjectInvitation

-- | @PUT \/api\/backend\/v1\/invitations\/project\/{invitationId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateProjectInvitation
  :: (Consumes UpdateProjectInvitation contentType, MimeRender contentType ProjectInvitationUpdateDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ProjectInvitationUpdateDTO -- ^ "update"
  -> InvitationId -- ^ "invitationId"
  -> NeptuneBackendRequest UpdateProjectInvitation contentType ProjectInvitationDTO accept
updateProjectInvitation :: ContentType contentType
-> Accept accept
-> ProjectInvitationUpdateDTO
-> InvitationId
-> NeptuneBackendRequest
     UpdateProjectInvitation contentType ProjectInvitationDTO accept
updateProjectInvitation ContentType contentType
_  Accept accept
_ ProjectInvitationUpdateDTO
update (InvitationId Text
invitationId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateProjectInvitation contentType ProjectInvitationDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/invitations/project/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
invitationId]
    NeptuneBackendRequest
  UpdateProjectInvitation contentType ProjectInvitationDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateProjectInvitation contentType ProjectInvitationDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateProjectInvitation contentType ProjectInvitationDTO accept
-> ProjectInvitationUpdateDTO
-> NeptuneBackendRequest
     UpdateProjectInvitation contentType ProjectInvitationDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ProjectInvitationUpdateDTO
update

data UpdateProjectInvitation
instance HasBodyParam UpdateProjectInvitation ProjectInvitationUpdateDTO

-- | @*/*@
instance MimeType mtype => Consumes UpdateProjectInvitation mtype

-- | @*/*@
instance MimeType mtype => Produces UpdateProjectInvitation mtype


-- *** updateProjectMember

-- | @PATCH \/api\/backend\/v1\/projects\/members\/{userId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateProjectMember
  :: (Consumes UpdateProjectMember contentType, MimeRender contentType ProjectMemberUpdateDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> ProjectMemberUpdateDTO -- ^ "member"
  -> ProjectIdentifier -- ^ "projectIdentifier"
  -> UserId -- ^ "userId"
  -> NeptuneBackendRequest UpdateProjectMember contentType ProjectMemberDTO accept
updateProjectMember :: ContentType contentType
-> Accept accept
-> ProjectMemberUpdateDTO
-> ProjectIdentifier
-> UserId
-> NeptuneBackendRequest
     UpdateProjectMember contentType ProjectMemberDTO accept
updateProjectMember ContentType contentType
_  Accept accept
_ ProjectMemberUpdateDTO
member (ProjectIdentifier Text
projectIdentifier) (UserId Text
userId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateProjectMember contentType ProjectMemberDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PATCH" [ByteString
"/api/backend/v1/projects/members/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
userId]
    NeptuneBackendRequest
  UpdateProjectMember contentType ProjectMemberDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateProjectMember contentType ProjectMemberDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateProjectMember contentType ProjectMemberDTO accept
-> ProjectMemberUpdateDTO
-> NeptuneBackendRequest
     UpdateProjectMember contentType ProjectMemberDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` ProjectMemberUpdateDTO
member
    NeptuneBackendRequest
  UpdateProjectMember contentType ProjectMemberDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     UpdateProjectMember contentType ProjectMemberDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"projectIdentifier", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
projectIdentifier)

data UpdateProjectMember
instance HasBodyParam UpdateProjectMember ProjectMemberUpdateDTO

-- | @*/*@
instance MimeType mtype => Consumes UpdateProjectMember mtype

-- | @*/*@
instance MimeType mtype => Produces UpdateProjectMember mtype


-- *** updateTags

-- | @PUT \/api\/leaderboard\/v1\/experiments\/tags@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
updateTags
  :: (Consumes UpdateTags contentType, MimeRender contentType UpdateTagsParams)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> UpdateTagsParams -- ^ "updateTagsParams"
  -> NeptuneBackendRequest UpdateTags contentType res accept
updateTags :: ContentType contentType
-> Accept accept
-> UpdateTagsParams
-> NeptuneBackendRequest UpdateTags contentType res accept
updateTags ContentType contentType
_  Accept accept
_ UpdateTagsParams
updateTagsParams =
  Method
-> [ByteString]
-> NeptuneBackendRequest UpdateTags contentType res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/leaderboard/v1/experiments/tags"]
    NeptuneBackendRequest UpdateTags contentType res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest UpdateTags contentType res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest UpdateTags contentType res accept
-> UpdateTagsParams
-> NeptuneBackendRequest UpdateTags contentType res accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` UpdateTagsParams
updateTagsParams

data UpdateTags
instance HasBodyParam UpdateTags UpdateTagsParams

-- | @*/*@
instance MimeType mtype => Consumes UpdateTags mtype

-- | @*/*@
instance MimeType mtype => Produces UpdateTags mtype


-- *** updateUserProfile

-- | @PATCH \/api\/backend\/v1\/userProfile@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateUserProfile
  :: (Consumes UpdateUserProfile contentType, MimeRender contentType UserProfileUpdateDTO)
  => ContentType contentType -- ^ request content-type ('MimeType')
  -> Accept accept -- ^ request accept ('MimeType')
  -> UserProfileUpdateDTO -- ^ "userProfileUpdate"
  -> NeptuneBackendRequest UpdateUserProfile contentType UserProfileDTO accept
updateUserProfile :: ContentType contentType
-> Accept accept
-> UserProfileUpdateDTO
-> NeptuneBackendRequest
     UpdateUserProfile contentType UserProfileDTO accept
updateUserProfile ContentType contentType
_  Accept accept
_ UserProfileUpdateDTO
userProfileUpdate =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateUserProfile contentType UserProfileDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PATCH" [ByteString
"/api/backend/v1/userProfile"]
    NeptuneBackendRequest
  UpdateUserProfile contentType UserProfileDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateUserProfile contentType UserProfileDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateUserProfile contentType UserProfileDTO accept
-> UserProfileUpdateDTO
-> NeptuneBackendRequest
     UpdateUserProfile contentType UserProfileDTO accept
forall req param contentType res accept.
(HasBodyParam req param, Consumes req contentType,
 MimeRender contentType param) =>
NeptuneBackendRequest req contentType res accept
-> param -> NeptuneBackendRequest req contentType res accept
`setBodyParam` UserProfileUpdateDTO
userProfileUpdate

data UpdateUserProfile
instance HasBodyParam UpdateUserProfile UserProfileUpdateDTO

-- | @*/*@
instance MimeType mtype => Consumes UpdateUserProfile mtype

-- | @*/*@
instance MimeType mtype => Produces UpdateUserProfile mtype


-- *** updateUserProfileAvatar

-- | @PUT \/api\/backend\/v1\/userProfile\/avatar@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
updateUserProfileAvatar
  :: (Consumes UpdateUserProfileAvatar MimeMultipartFormData)
  => Accept accept -- ^ request accept ('MimeType')
  -> AvatarFile -- ^ "avatarFile"
  -> NeptuneBackendRequest UpdateUserProfileAvatar MimeMultipartFormData LinkDTO accept
updateUserProfileAvatar :: Accept accept
-> AvatarFile
-> NeptuneBackendRequest
     UpdateUserProfileAvatar MimeMultipartFormData LinkDTO accept
updateUserProfileAvatar  Accept accept
_ (AvatarFile FilePath
avatarFile) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UpdateUserProfileAvatar MimeMultipartFormData LinkDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"PUT" [ByteString
"/api/backend/v1/userProfile/avatar"]
    NeptuneBackendRequest
  UpdateUserProfileAvatar MimeMultipartFormData LinkDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UpdateUserProfileAvatar MimeMultipartFormData LinkDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)
    NeptuneBackendRequest
  UpdateUserProfileAvatar MimeMultipartFormData LinkDTO accept
-> Part
-> NeptuneBackendRequest
     UpdateUserProfileAvatar MimeMultipartFormData LinkDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> Part -> NeptuneBackendRequest req contentType res accept
`_addMultiFormPart` Text -> FilePath -> Part
NH.partFileSource Text
"avatarFile" FilePath
avatarFile

data UpdateUserProfileAvatar

-- | @multipart/form-data@
instance Consumes UpdateUserProfileAvatar MimeMultipartFormData

-- | @*/*@
instance MimeType mtype => Produces UpdateUserProfileAvatar mtype


-- *** uploadExperimentOutput

-- | @POST \/api\/leaderboard\/v1\/storage\/legacy\/uploadOutput\/{experimentId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
uploadExperimentOutput
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest UploadExperimentOutput MimeNoContent res accept
uploadExperimentOutput :: Accept accept
-> ExperimentId
-> NeptuneBackendRequest
     UploadExperimentOutput MimeNoContent res accept
uploadExperimentOutput  Accept accept
_ (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UploadExperimentOutput MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/storage/legacy/uploadOutput/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
experimentId]
    NeptuneBackendRequest
  UploadExperimentOutput MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UploadExperimentOutput MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data UploadExperimentOutput
-- | @*/*@
instance MimeType mtype => Produces UploadExperimentOutput mtype


-- *** uploadExperimentOutputAsTarstream

-- | @POST \/api\/leaderboard\/v1\/storage\/legacy\/uploadOutputAsTarStream\/{experimentId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
uploadExperimentOutputAsTarstream
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest UploadExperimentOutputAsTarstream MimeNoContent res accept
uploadExperimentOutputAsTarstream :: Accept accept
-> ExperimentId
-> NeptuneBackendRequest
     UploadExperimentOutputAsTarstream MimeNoContent res accept
uploadExperimentOutputAsTarstream  Accept accept
_ (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UploadExperimentOutputAsTarstream MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/storage/legacy/uploadOutputAsTarStream/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
experimentId]
    NeptuneBackendRequest
  UploadExperimentOutputAsTarstream MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UploadExperimentOutputAsTarstream MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data UploadExperimentOutputAsTarstream
-- | @*/*@
instance MimeType mtype => Produces UploadExperimentOutputAsTarstream mtype


-- *** uploadExperimentSource

-- | @POST \/api\/leaderboard\/v1\/storage\/legacy\/uploadSource\/{experimentId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
uploadExperimentSource
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest UploadExperimentSource MimeNoContent res accept
uploadExperimentSource :: Accept accept
-> ExperimentId
-> NeptuneBackendRequest
     UploadExperimentSource MimeNoContent res accept
uploadExperimentSource  Accept accept
_ (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UploadExperimentSource MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/storage/legacy/uploadSource/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
experimentId]
    NeptuneBackendRequest
  UploadExperimentSource MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UploadExperimentSource MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data UploadExperimentSource
-- | @*/*@
instance MimeType mtype => Produces UploadExperimentSource mtype


-- *** uploadExperimentSourceAsTarstream

-- | @POST \/api\/leaderboard\/v1\/storage\/legacy\/uploadSourceAsTarStream\/{experimentId}@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
-- Note: Has 'Produces' instances, but no response schema
--
uploadExperimentSourceAsTarstream
  :: Accept accept -- ^ request accept ('MimeType')
  -> ExperimentId -- ^ "experimentId"
  -> NeptuneBackendRequest UploadExperimentSourceAsTarstream MimeNoContent res accept
uploadExperimentSourceAsTarstream :: Accept accept
-> ExperimentId
-> NeptuneBackendRequest
     UploadExperimentSourceAsTarstream MimeNoContent res accept
uploadExperimentSourceAsTarstream  Accept accept
_ (ExperimentId Text
experimentId) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UploadExperimentSourceAsTarstream MimeNoContent res accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"POST" [ByteString
"/api/leaderboard/v1/storage/legacy/uploadSourceAsTarStream/",Text -> ByteString
forall a. ToHttpApiData a => a -> ByteString
toPath Text
experimentId]
    NeptuneBackendRequest
  UploadExperimentSourceAsTarstream MimeNoContent res accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UploadExperimentSourceAsTarstream MimeNoContent res accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data UploadExperimentSourceAsTarstream
-- | @*/*@
instance MimeType mtype => Produces UploadExperimentSourceAsTarstream mtype


-- *** userPricingStatus

-- | @GET \/api\/backend\/v1\/payments\/user\/pricingStatus@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
userPricingStatus
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest UserPricingStatus MimeNoContent UserPricingStatusDTO accept
userPricingStatus :: Accept accept
-> NeptuneBackendRequest
     UserPricingStatus MimeNoContent UserPricingStatusDTO accept
userPricingStatus  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     UserPricingStatus MimeNoContent UserPricingStatusDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/payments/user/pricingStatus"]
    NeptuneBackendRequest
  UserPricingStatus MimeNoContent UserPricingStatusDTO accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest
     UserPricingStatus MimeNoContent UserPricingStatusDTO accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data UserPricingStatus
-- | @*/*@
instance MimeType mtype => Produces UserPricingStatus mtype


-- *** validateUsername

-- | @GET \/api\/backend\/v1\/login\/username\/validate@
--
validateUsername
  :: Accept accept -- ^ request accept ('MimeType')
  -> UsernameText -- ^ "username"
  -> NeptuneBackendRequest ValidateUsername MimeNoContent UsernameValidationStatusDTO accept
validateUsername :: Accept accept
-> UsernameText
-> NeptuneBackendRequest
     ValidateUsername MimeNoContent UsernameValidationStatusDTO accept
validateUsername  Accept accept
_ (UsernameText Text
username) =
  Method
-> [ByteString]
-> NeptuneBackendRequest
     ValidateUsername MimeNoContent UsernameValidationStatusDTO accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/v1/login/username/validate"]
    NeptuneBackendRequest
  ValidateUsername MimeNoContent UsernameValidationStatusDTO accept
-> [QueryItem]
-> NeptuneBackendRequest
     ValidateUsername MimeNoContent UsernameValidationStatusDTO accept
forall req contentType res accept.
NeptuneBackendRequest req contentType res accept
-> [QueryItem] -> NeptuneBackendRequest req contentType res accept
`addQuery` (Method, Maybe Text) -> [QueryItem]
forall a. ToHttpApiData a => (Method, Maybe a) -> [QueryItem]
toQuery (Method
"username", Text -> Maybe Text
forall a. a -> Maybe a
Just Text
username)

data ValidateUsername
-- | @*/*@
instance MimeType mtype => Produces ValidateUsername mtype


-- *** version0

-- | @GET \/api\/backend\/version@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
version0
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest Version0 MimeNoContent Version accept
version0 :: Accept accept
-> NeptuneBackendRequest Version0 MimeNoContent Version accept
version0  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest Version0 MimeNoContent Version accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/api/backend/version"]
    NeptuneBackendRequest Version0 MimeNoContent Version accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest Version0 MimeNoContent Version accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data Version0
-- | @*/*@
instance MimeType mtype => Produces Version0 mtype


-- *** versionGet

-- | @GET \/version@
--
-- AuthMethod: 'AuthOAuthOauth2'
--
versionGet
  :: Accept accept -- ^ request accept ('MimeType')
  -> NeptuneBackendRequest VersionGet MimeNoContent Version accept
versionGet :: Accept accept
-> NeptuneBackendRequest VersionGet MimeNoContent Version accept
versionGet  Accept accept
_ =
  Method
-> [ByteString]
-> NeptuneBackendRequest VersionGet MimeNoContent Version accept
forall req contentType res accept.
Method
-> [ByteString] -> NeptuneBackendRequest req contentType res accept
_mkRequest Method
"GET" [ByteString
"/version"]
    NeptuneBackendRequest VersionGet MimeNoContent Version accept
-> Proxy AuthOAuthOauth2
-> NeptuneBackendRequest VersionGet MimeNoContent Version accept
forall authMethod req contentType res accept.
AuthMethod authMethod =>
NeptuneBackendRequest req contentType res accept
-> Proxy authMethod
-> NeptuneBackendRequest req contentType res accept
`_hasAuthType` (Proxy AuthOAuthOauth2
forall k (t :: k). Proxy t
P.Proxy :: P.Proxy AuthOAuthOauth2)

data VersionGet
-- | @*/*@
instance MimeType mtype => Produces VersionGet mtype