https://github.com/purescript/package-sets/releases/download/psc-0.13.8-20200615/packages.dhall sha256:5d0cfad9408c84db0a3fdcea2d708f9ed8f64297e164dc57a7cf6328706df93a

      https://github.com/purescript/package-sets/releases/download/psc-0.13.8-20210118/packages.dhall sha256:a59c5c93a68d5d066f3815a89f398bcf00e130a51cb185b2da29b20e2d8ae115

let additions = {=}

let additions =
      { halogen-portal =
        { dependencies =
          [ "aff-bus"
          , "effect"
          , "halogen"
          , "halogen-storybook"
          , "psci-support"
          , "record"
          ]
        , repo =
            "https://github.com/thomashoneyman/purescript-halogen-portal.git"
        , version = "34bcb2bb1dd859749f2061479c74c6052519e115"
        }
      }

  , "halogen-portal"

import Data.Argonaut.Decode (class DecodeJson, decodeJson)

import Data.Argonaut.Decode (class DecodeJson, decodeJson, JsonDecodeError(..))

    BillableId <$> (note "Failed to decode billable UUID" $ parseUUID uuidStr)

    BillableId <$> note (TypeMismatch"Failed to decode billable UUID") (parseUUID uuidStr)

    PaymentRequestId <$> (note "Failed to decode paymentRequest UUID" $ parseUUID uuidStr)

    PaymentRequestId <$> note (TypeMismatch "Failed to decode paymentRequest UUID") (parseUUID uuidStr)

      StatusCode 200 -> withExceptT (ParseFailure r.body) <<< except $ decodeJson r.body

      StatusCode 200 -> withExceptT ParseFailure <<< except $ decodeJson r.body

import Data.Argonaut.Decode (class DecodeJson, decodeJson)

import Data.Argonaut.Decode (class DecodeJson, decodeJson, JsonDecodeError(..))

parseJsonDate :: Json -> ExceptT String Effect DateTime

parseJsonDate :: Json -> ExceptT JsonDecodeError Effect DateTime

  parseDate str

  (withExceptT TypeMismatch $ parseDate str)

  = Json -> Either String a

  = Json -> Either JsonDecodeError a

decodeDatedJson :: forall t. Traversable t => Decode (t String) -> Json -> ExceptT String Effect (t DateTime)

decodeDatedJson :: 
  forall t. 
  Traversable t => 
  Decode (t String) -> 
  Json -> 
  ExceptT JsonDecodeError Effect (t DateTime)

  traverse parseDate decoded

  (withExceptT TypeMismatch $ traverse parseDate decoded)

    StatusCode 200 -> withExceptT (ParseFailure r.body) $ map fromDateTime <$> decodeDatedJson decode r.body

    StatusCode 200 -> withExceptT ParseFailure $ map fromDateTime <$> decodeDatedJson decode r.body

      withExceptT (ParseFailure r.body)
        $ Just
        <<< map fromDateTime
        <$> decodeDatedJson decode r.body
    other -> throwError $ Error { status: Just other, message: r.statusText }

      map Just
      <<< withExceptT ParseFailure
      <<< map (map fromDateTime)
      $ decodeDatedJson decode r.body
    other -> 
      throwError $ Error { status: Just other, message: r.statusText }

import Data.Argonaut.Core (Json)
import Data.Argonaut.Decode (class DecodeJson, decodeJson, (.:))

import Data.Argonaut.Core (Json, fromString)
import Data.Argonaut.Decode (class DecodeJson, JsonDecodeError(..), decodeJson, (.:))

      other -> Left $ "Unrecognized depreciation function: " <> other

      other -> Left $ UnexpectedValue (fromString dtype)

parseProject :: ProjectId -> Object Json -> Either String (Project' String)

parseProject :: ProjectId -> Object Json -> Either JsonDecodeError (Project' String)

import Data.Argonaut.Decode (class DecodeJson, decodeJson, (.:), (.:?))

import Data.Argonaut.Decode (class DecodeJson, JsonDecodeError(..), decodeJson, (.:), (.:?))

parseEventFields :: Object Json -> Either String (Event String)

parseEventFields :: Object Json -> Either JsonDecodeError (Event String)

  note "Only 'stop' and 'start' events are supported."

  note (TypeMismatch "Only 'stop' and 'start' events are supported.")

import Data.Argonaut.Core (Json, stringify)

import Data.Argonaut.Decode (JsonDecodeError)

  | ParseFailure Json String

  | ParseFailure JsonDecodeError

    ParseFailure js e -> "ParseFailure (" <> show (stringify js) <> ") " <> show e

    ParseFailure e -> "ParseFailure (" <> show e <> ") " 

import Data.Argonaut.Decode (class DecodeJson, decodeJson)

import Data.Argonaut.Decode (class DecodeJson, decodeJson, JsonDecodeError(..))

    UserId <$> (note "Failed to decode user UUID" $ parseUUID uuidStr)

    UserId <$> note (TypeMismatch "Failed to decode user UUID") (parseUUID uuidStr)

    ProjectId <$> (note "Failed to decode project UUID" $ parseUUID uuidStr)

    ProjectId <$> note (TypeMismatch "Failed to decode project UUID") (parseUUID uuidStr)