Literals.hs

-- Note: this is an automatically generated file. Do not edit.

-- | DSL functions for hydra.lib.literals

module Hydra.Dsl.Lib.Literals where

import qualified Hydra.Ast as Ast
import qualified Hydra.Coders as Coders
import qualified Hydra.Core as Core
import qualified Hydra.Docs as Docs
import qualified Hydra.Dsl.Ast as DslAst
import qualified Hydra.Dsl.Coders as DslCoders
import qualified Hydra.Dsl.Core as DslCore
import qualified Hydra.Dsl.Docs as DslDocs
import qualified Hydra.Dsl.Error.Checking as ErrorChecking
import qualified Hydra.Dsl.Error.Core as DslErrorCore
import qualified Hydra.Dsl.Error.File as DslErrorFile
import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging
import qualified Hydra.Dsl.Error.System as DslErrorSystem
import qualified Hydra.Dsl.Errors as DslErrors
import qualified Hydra.Dsl.File as DslFile
import qualified Hydra.Dsl.Graph as DslGraph
import qualified Hydra.Dsl.Json.Model as JsonModel
import qualified Hydra.Dsl.Packaging as DslPackaging
import qualified Hydra.Dsl.Parsing as DslParsing
import qualified Hydra.Dsl.Paths as DslPaths
import qualified Hydra.Dsl.Query as DslQuery
import qualified Hydra.Dsl.Regex as DslRegex
import qualified Hydra.Dsl.Relational as DslRelational
import qualified Hydra.Dsl.System as DslSystem
import qualified Hydra.Dsl.Tabular as DslTabular
import qualified Hydra.Dsl.Testing as DslTesting
import qualified Hydra.Dsl.Time as DslTime
import qualified Hydra.Dsl.Topology as DslTopology
import qualified Hydra.Dsl.Typing as DslTyping
import qualified Hydra.Dsl.Util as DslUtil
import qualified Hydra.Dsl.Validation as DslValidation
import qualified Hydra.Dsl.Variants as DslVariants
import qualified Hydra.Error.Checking as Checking
import qualified Hydra.Error.Core as ErrorCore
import qualified Hydra.Error.File as ErrorFile
import qualified Hydra.Error.Packaging as ErrorPackaging
import qualified Hydra.Error.System as ErrorSystem
import qualified Hydra.Errors as Errors
import qualified Hydra.File as File
import qualified Hydra.Graph as Graph
import qualified Hydra.Json.Model as Model
import qualified Hydra.Packaging as Packaging
import qualified Hydra.Parsing as Parsing
import qualified Hydra.Paths as Paths
import qualified Hydra.Query as Query
import qualified Hydra.Regex as Regex
import qualified Hydra.Relational as Relational
import qualified Hydra.System as System
import qualified Hydra.Tabular as Tabular
import qualified Hydra.Testing as Testing
import qualified Hydra.Time as Time
import qualified Hydra.Topology as Topology
import qualified Hydra.Typed as Typed
import qualified Hydra.Typing as Typing
import qualified Hydra.Util as Util
import qualified Hydra.Validation as Validation
import qualified Hydra.Variants as Variants
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void
import qualified Data.ByteString as B
import qualified Data.Int as I

-- | DSL reference to hydra.lib.literals.base64ToBinary
base64ToBinary :: Typed.TypedTerm String -> Typed.TypedTerm B.ByteString
base64ToBinary s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.base64ToBinary")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.bigintToDecimal
bigintToDecimal :: Typed.TypedTerm Integer -> Typed.TypedTerm Sci.Scientific
bigintToDecimal x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.bigintToDecimal")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.bigintToInt16
bigintToInt16 :: Typed.TypedTerm Integer -> Typed.TypedTerm I.Int16
bigintToInt16 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.bigintToInt16")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.bigintToInt32
bigintToInt32 :: Typed.TypedTerm Integer -> Typed.TypedTerm Int
bigintToInt32 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.bigintToInt32")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.bigintToInt64
bigintToInt64 :: Typed.TypedTerm Integer -> Typed.TypedTerm I.Int64
bigintToInt64 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.bigintToInt64")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.bigintToInt8
bigintToInt8 :: Typed.TypedTerm Integer -> Typed.TypedTerm I.Int8
bigintToInt8 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.bigintToInt8")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.bigintToUint16
bigintToUint16 :: Typed.TypedTerm Integer -> Typed.TypedTerm Int
bigintToUint16 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.bigintToUint16")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.bigintToUint32
bigintToUint32 :: Typed.TypedTerm Integer -> Typed.TypedTerm I.Int64
bigintToUint32 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.bigintToUint32")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.bigintToUint64
bigintToUint64 :: Typed.TypedTerm Integer -> Typed.TypedTerm Integer
bigintToUint64 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.bigintToUint64")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.bigintToUint8
bigintToUint8 :: Typed.TypedTerm Integer -> Typed.TypedTerm I.Int16
bigintToUint8 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.bigintToUint8")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.binaryToBase64
binaryToBase64 :: Typed.TypedTerm B.ByteString -> Typed.TypedTerm String
binaryToBase64 b =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.binaryToBase64")),
      Core.applicationArgument = (Typed.unTypedTerm b)}))

-- | DSL reference to hydra.lib.literals.binaryToBytes
binaryToBytes :: Typed.TypedTerm B.ByteString -> Typed.TypedTerm [Int]
binaryToBytes b =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.binaryToBytes")),
      Core.applicationArgument = (Typed.unTypedTerm b)}))

-- | DSL reference to hydra.lib.literals.decimalToBigint
decimalToBigint :: Typed.TypedTerm Sci.Scientific -> Typed.TypedTerm Integer
decimalToBigint x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.decimalToBigint")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.decimalToFloat32
decimalToFloat32 :: Typed.TypedTerm Sci.Scientific -> Typed.TypedTerm Float
decimalToFloat32 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.decimalToFloat32")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.decimalToFloat64
decimalToFloat64 :: Typed.TypedTerm Sci.Scientific -> Typed.TypedTerm Double
decimalToFloat64 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.decimalToFloat64")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.float32ToDecimal
float32ToDecimal :: Typed.TypedTerm Float -> Typed.TypedTerm Sci.Scientific
float32ToDecimal x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.float32ToDecimal")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.float32ToFloat64
float32ToFloat64 :: Typed.TypedTerm Float -> Typed.TypedTerm Double
float32ToFloat64 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.float32ToFloat64")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.float64ToDecimal
float64ToDecimal :: Typed.TypedTerm Double -> Typed.TypedTerm Sci.Scientific
float64ToDecimal x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.float64ToDecimal")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.float64ToFloat32
float64ToFloat32 :: Typed.TypedTerm Double -> Typed.TypedTerm Float
float64ToFloat32 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.float64ToFloat32")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.int16ToBigint
int16ToBigint :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm Integer
int16ToBigint x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.int16ToBigint")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.int32ToBigint
int32ToBigint :: Typed.TypedTerm Int -> Typed.TypedTerm Integer
int32ToBigint x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.int32ToBigint")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.int64ToBigint
int64ToBigint :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Integer
int64ToBigint x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.int64ToBigint")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.int8ToBigint
int8ToBigint :: Typed.TypedTerm I.Int8 -> Typed.TypedTerm Integer
int8ToBigint x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.int8ToBigint")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.parseBigint
parseBigint :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Integer)
parseBigint s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseBigint")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseBoolean
parseBoolean :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Bool)
parseBoolean s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseBoolean")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseDecimal
parseDecimal :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Sci.Scientific)
parseDecimal s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseDecimal")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseFloat32
parseFloat32 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Float)
parseFloat32 s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseFloat32")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseFloat64
parseFloat64 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Double)
parseFloat64 s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseFloat64")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseInt16
parseInt16 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe I.Int16)
parseInt16 s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseInt16")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseInt32
parseInt32 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Int)
parseInt32 s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseInt32")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseInt64
parseInt64 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe I.Int64)
parseInt64 s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseInt64")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseInt8
parseInt8 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe I.Int8)
parseInt8 s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseInt8")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseString
parseString :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String)
parseString s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseString")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseUint16
parseUint16 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Int)
parseUint16 s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseUint16")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseUint32
parseUint32 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe I.Int64)
parseUint32 s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseUint32")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseUint64
parseUint64 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Integer)
parseUint64 s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseUint64")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.parseUint8
parseUint8 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe I.Int16)
parseUint8 s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.parseUint8")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.printBigint
printBigint :: Typed.TypedTerm Integer -> Typed.TypedTerm String
printBigint x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printBigint")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.printBoolean
printBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm String
printBoolean b =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printBoolean")),
      Core.applicationArgument = (Typed.unTypedTerm b)}))

-- | DSL reference to hydra.lib.literals.printDecimal
printDecimal :: Typed.TypedTerm Sci.Scientific -> Typed.TypedTerm String
printDecimal x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printDecimal")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.printFloat32
printFloat32 :: Typed.TypedTerm Float -> Typed.TypedTerm String
printFloat32 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printFloat32")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.printFloat64
printFloat64 :: Typed.TypedTerm Double -> Typed.TypedTerm String
printFloat64 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printFloat64")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.printInt16
printInt16 :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm String
printInt16 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printInt16")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.printInt32
printInt32 :: Typed.TypedTerm Int -> Typed.TypedTerm String
printInt32 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printInt32")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.printInt64
printInt64 :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm String
printInt64 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printInt64")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.printInt8
printInt8 :: Typed.TypedTerm I.Int8 -> Typed.TypedTerm String
printInt8 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printInt8")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.printString
printString :: Typed.TypedTerm String -> Typed.TypedTerm String
printString s =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printString")),
      Core.applicationArgument = (Typed.unTypedTerm s)}))

-- | DSL reference to hydra.lib.literals.printUint16
printUint16 :: Typed.TypedTerm Int -> Typed.TypedTerm String
printUint16 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printUint16")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.printUint32
printUint32 :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm String
printUint32 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printUint32")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.printUint64
printUint64 :: Typed.TypedTerm Integer -> Typed.TypedTerm String
printUint64 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printUint64")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.printUint8
printUint8 :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm String
printUint8 x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.printUint8")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.uint16ToBigint
uint16ToBigint :: Typed.TypedTerm Int -> Typed.TypedTerm Integer
uint16ToBigint x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.uint16ToBigint")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.uint32ToBigint
uint32ToBigint :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Integer
uint32ToBigint x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.uint32ToBigint")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.uint64ToBigint
uint64ToBigint :: Typed.TypedTerm Integer -> Typed.TypedTerm Integer
uint64ToBigint x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.uint64ToBigint")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL reference to hydra.lib.literals.uint8ToBigint
uint8ToBigint :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm Integer
uint8ToBigint x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.literals.uint8ToBigint")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))