{-# LANGUAGE Haskell2010                #-}
{-# LANGUAGE BangPatterns               #-}
{-# LANGUAGE BinaryLiterals             #-}
{-# LANGUAGE ConstraintKinds            #-}
{-# LANGUAGE CPP                        #-}
{-# LANGUAGE DefaultSignatures          #-}
{-# LANGUAGE DeriveAnyClass             #-}
{-# LANGUAGE DeriveFunctor              #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE DeriveLift                 #-}
{-# LANGUAGE DerivingStrategies         #-}
{-# LANGUAGE DerivingVia                #-}
{-# LANGUAGE ExistentialQuantification  #-}
{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE FunctionalDependencies     #-}
{-# LANGUAGE GADTs                      #-}
{-# LANGUAGE GeneralisedNewtypeDeriving #-}
{-# LANGUAGE InstanceSigs               #-}
{-# LANGUAGE LambdaCase                 #-}
{-# LANGUAGE MultiWayIf                 #-}
{-# LANGUAGE NumericUnderscores         #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE PackageImports             #-}
{-# LANGUAGE QuasiQuotes                #-}
{-# LANGUAGE RankNTypes                 #-}
{-# LANGUAGE RecordWildCards            #-}
{-# LANGUAGE ScopedTypeVariables        #-}
{-# LANGUAGE StandaloneDeriving         #-}
{-# LANGUAGE StrictData                 #-}
{-# LANGUAGE TemplateHaskell            #-}
{-# LANGUAGE TupleSections              #-}
{-# LANGUAGE TypeApplications           #-}
{-# LANGUAGE TypeFamilies               #-}

module Data.Multibase.Types.Multibase 
  ( Multibase(..)
  , module Data.Multibase.Types.Multibase
  ) where

import           Data.Multibase.Types.Internal.IsMultibase
import           Data.Multibase.Types.Internal.IsCodec


----------------------------------------------------------------------------------------------------
-- decoding
----------------------------------------------------------------------------------------------------

-- | decode the input 'Multibase' to a 'ByteString', or 'MbDecodeFailure' on failure
decodeMultibase :: Multibase -> Either MbDecodeFailure ByteString
decodeMultibase = decodingMultibase

-- | decode the input 'Multibase' to a 'ByteString', or 'MbDecodeFailure' on failure
decodeMultibaseToText :: Multibase -> Either MbDecodeFailure Text
decodeMultibaseToText = decodingMultibaseToText


----------------------------------------------------------------------------------------------------
-- encode*With
----------------------------------------------------------------------------------------------------

encodeToMultibaseWith :: MbAlgorithm -> ByteString -> Multibase
encodeToMultibaseWith = encodingToMultibase

encodeTextToMultibaseWith :: MbAlgorithm -> Text -> Multibase
encodeTextToMultibaseWith = encodingTextToMultibase


----------------------------------------------------------------------------------------------------
-- encoding
----------------------------------------------------------------------------------------------------

-- | encode the input 'ByteString' to 'Multibase' via the 'IdentityBase' codec
encodeIdentityBaseToMultibase :: ByteString -> Multibase
encodeIdentityBaseToMultibase = encodingToMultibase_ $ Proxy @IdentityBase

-- | encode the input 'Text' to 'Multibase' via the 'IdentityBase' codec
encodeTextInIdentityBaseToMultibase :: Text -> Multibase
encodeTextInIdentityBaseToMultibase = encodingTextToMultibase_ $ Proxy @IdentityBase

-- | encode the input 'ByteString' to 'Multibase' via the 'Base2' codec
encodeBase2ToMultibase :: ByteString -> Multibase
encodeBase2ToMultibase = encodingToMultibase_ $ Proxy @Base2

-- | encode the input 'Text' to 'Multibase' via the 'Base2' codec
encodeTextInBase2ToMultibase :: Text -> Multibase
encodeTextInBase2ToMultibase = encodingTextToMultibase_ $ Proxy @Base2

-- | encode the input 'ByteString' to 'Multibase' via the 'Base8' codec
encodeBase8ToMultibase :: ByteString -> Multibase
encodeBase8ToMultibase = encodingToMultibase_ $ Proxy @Base8

-- | encode the input 'Text' to 'Multibase' via the 'Base8' codec
encodeTextInBase8ToMultibase :: Text -> Multibase
encodeTextInBase8ToMultibase = encodingTextToMultibase_ $ Proxy @Base8

-- | encode the input 'ByteString' to 'Multibase' via the 'Base10' codec
encodeBase10ToMultibase :: ByteString -> Multibase
encodeBase10ToMultibase = encodingToMultibase_ $ Proxy @Base10

-- | encode the input 'Text' to 'Multibase' via the 'Base10' codec
encodeTextInBase10ToMultibase :: Text -> Multibase
encodeTextInBase10ToMultibase = encodingTextToMultibase_ $ Proxy @Base10

-- | encode the input 'ByteString' to 'Multibase' via the 'Base16Lower' codec
encodeBase16LowerToMultibase :: ByteString -> Multibase
encodeBase16LowerToMultibase = encodingToMultibase_ $ Proxy @Base16Lower

-- | encode the input 'Text' to 'Multibase' via the 'Base16Lower' codec
encodeTextInBase16LowerToMultibase :: Text -> Multibase
encodeTextInBase16LowerToMultibase = encodingTextToMultibase_ $ Proxy @Base16Lower

-- | encode the input 'ByteString' to 'Multibase' via the 'Base16Upper' codec
encodeBase16UpperToMultibase :: ByteString -> Multibase
encodeBase16UpperToMultibase = encodingToMultibase_ $ Proxy @Base16Upper

-- | encode the input 'Text' to 'Multibase' via the 'Base16Upper' codec
encodeTextInBase16UpperToMultibase :: Text -> Multibase
encodeTextInBase16UpperToMultibase = encodingTextToMultibase_ $ Proxy @Base16Upper

-- | encode the input 'ByteString' to 'Multibase' via the 'Base32HexNoPadLower' codec
encodeBase32HexNoPadLowerToMultibase :: ByteString -> Multibase
encodeBase32HexNoPadLowerToMultibase = encodingToMultibase_ $ Proxy @Base32HexNoPadLower

-- | encode the input 'Text' to 'Multibase' via the 'Base32HexNoPadLower' codec
encodeTextInBase32HexNoPadLowerToMultibase :: Text -> Multibase
encodeTextInBase32HexNoPadLowerToMultibase = encodingTextToMultibase_ $ Proxy @Base32HexNoPadLower

-- | encode the input 'ByteString' to 'Multibase' via the 'Base32HexNoPadUpper' codec
encodeBase32HexNoPadUpperToMultibase :: ByteString -> Multibase
encodeBase32HexNoPadUpperToMultibase = encodingToMultibase_ $ Proxy @Base32HexNoPadUpper

-- | encode the input 'Text' to 'Multibase' via the 'Base32HexNoPadUpper' codec
encodeTextInBase32HexNoPadUpperToMultibase :: Text -> Multibase
encodeTextInBase32HexNoPadUpperToMultibase = encodingTextToMultibase_ $ Proxy @Base32HexNoPadUpper

-- | encode the input 'ByteString' to 'Multibase' via the 'Base32HexPadLower' codec
encodeBase32HexPadLowerToMultibase :: ByteString -> Multibase
encodeBase32HexPadLowerToMultibase = encodingToMultibase_ $ Proxy @Base32HexPadLower

-- | encode the input 'Text' to 'Multibase' via the 'Base32HexPadLower' codec
encodeTextInBase32HexPadLowerToMultibase :: Text -> Multibase
encodeTextInBase32HexPadLowerToMultibase = encodingTextToMultibase_ $ Proxy @Base32HexPadLower

-- | encode the input 'ByteString' to 'Multibase' via the 'Base32HexPadUpper' codec
encodeBase32HexPadUpperToMultibase :: ByteString -> Multibase
encodeBase32HexPadUpperToMultibase = encodingToMultibase_ $ Proxy @Base32HexPadUpper

-- | encode the input 'Text' to 'Multibase' via the 'Base32HexPadUpper' codec
encodeTextInBase32HexPadUpperToMultibase :: Text -> Multibase
encodeTextInBase32HexPadUpperToMultibase = encodingTextToMultibase_ $ Proxy @Base32HexPadUpper

-- | encode the input 'ByteString' to 'Multibase' via the 'Base32NoPadLower' codec
encodeBase32NoPadLowerToMultibase :: ByteString -> Multibase
encodeBase32NoPadLowerToMultibase = encodingToMultibase_ $ Proxy @Base32NoPadLower

-- | encode the input 'Text' to 'Multibase' via the 'Base32NoPadLower' codec
encodeTextInBase32NoPadLowerToMultibase :: Text -> Multibase
encodeTextInBase32NoPadLowerToMultibase = encodingTextToMultibase_ $ Proxy @Base32NoPadLower

-- | encode the input 'ByteString' to 'Multibase' via the 'Base32NoPadUpper' codec
encodeBase32NoPadUpperToMultibase :: ByteString -> Multibase
encodeBase32NoPadUpperToMultibase = encodingToMultibase_ $ Proxy @Base32NoPadUpper

-- | encode the input 'Text' to 'Multibase' via the 'Base32NoPadUpper' codec
encodeTextInBase32NoPadUpperToMultibase :: Text -> Multibase
encodeTextInBase32NoPadUpperToMultibase = encodingTextToMultibase_ $ Proxy @Base32NoPadUpper

-- | encode the input 'ByteString' to 'Multibase' via the 'Base32PadLower' codec
encodeBase32PadLowerToMultibase :: ByteString -> Multibase
encodeBase32PadLowerToMultibase = encodingToMultibase_ $ Proxy @Base32PadLower

-- | encode the input 'Text' to 'Multibase' via the 'Base32PadLower' codec
encodeTextInBase32PadLowerToMultibase :: Text -> Multibase
encodeTextInBase32PadLowerToMultibase = encodingTextToMultibase_ $ Proxy @Base32PadLower

-- | encode the input 'ByteString' to 'Multibase' via the 'Base32PadUpper' codec
encodeBase32PadUpperToMultibase :: ByteString -> Multibase
encodeBase32PadUpperToMultibase = encodingToMultibase_ $ Proxy @Base32PadUpper

-- | encode the input 'Text' to 'Multibase' via the 'Base32PadUpper' codec
encodeTextInBase32PadUpperToMultibase :: Text -> Multibase
encodeTextInBase32PadUpperToMultibase = encodingTextToMultibase_ $ Proxy @Base32PadUpper

-- | encode the input 'ByteString' to 'Multibase' via the 'Base32z' codec
encodeBase32zToMultibase :: ByteString -> Multibase
encodeBase32zToMultibase = encodingToMultibase_ $ Proxy @Base32z

-- | encode the input 'Text' to 'Multibase' via the 'Base32z' codec
encodeTextInBase32zToMultibase :: Text -> Multibase
encodeTextInBase32zToMultibase = encodingTextToMultibase_ $ Proxy @Base32z

-- | encode the input 'ByteString' to 'Multibase' via the 'Base36Lower' codec
encodeBase36LowerToMultibase :: ByteString -> Multibase
encodeBase36LowerToMultibase = encodingToMultibase_ $ Proxy @Base36Lower

-- | encode the input 'Text' to 'Multibase' via the 'Base36Lower' codec
encodeTextInBase36LowerToMultibase :: Text -> Multibase
encodeTextInBase36LowerToMultibase = encodingTextToMultibase_ $ Proxy @Base36Lower

-- | encode the input 'ByteString' to 'Multibase' via the 'Base36Upper' codec
encodeBase36UpperToMultibase :: ByteString -> Multibase
encodeBase36UpperToMultibase = encodingToMultibase_ $ Proxy @Base36Upper

-- | encode the input 'Text' to 'Multibase' via the 'Base36Upper' codec
encodeTextInBase36UpperToMultibase :: Text -> Multibase
encodeTextInBase36UpperToMultibase = encodingTextToMultibase_ $ Proxy @Base36Upper

-- | encode the input 'ByteString' to 'Multibase' via the 'Base58Btc' codec
encodeBase58BtcToMultibase :: ByteString -> Multibase
encodeBase58BtcToMultibase = encodingToMultibase_ $ Proxy @Base58Btc

-- | encode the input 'Text' to 'Multibase' via the 'Base58Btc' codec
encodeTextInBase58BtcToMultibase :: Text -> Multibase
encodeTextInBase58BtcToMultibase = encodingTextToMultibase_ $ Proxy @Base58Btc

-- | encode the input 'ByteString' to 'Multibase' via the 'Base58Flickr' codec
encodeBase58FlickrToMultibase :: ByteString -> Multibase
encodeBase58FlickrToMultibase = encodingToMultibase_ $ Proxy @Base58Flickr

-- | encode the input 'Text' to 'Multibase' via the 'Base58Flickr' codec
encodeTextInBase58FlickrToMultibase :: Text -> Multibase
encodeTextInBase58FlickrToMultibase = encodingTextToMultibase_ $ Proxy @Base58Flickr

-- | encode the input 'ByteString' to 'Multibase' via the 'Base64NoPad' codec
encodeBase64NoPadToMultibase :: ByteString -> Multibase
encodeBase64NoPadToMultibase = encodingToMultibase_ $ Proxy @Base64NoPad

-- | encode the input 'Text' to 'Multibase' via the 'Base64NoPad' codec
encodeTextInBase64NoPadToMultibase :: Text -> Multibase
encodeTextInBase64NoPadToMultibase = encodingTextToMultibase_ $ Proxy @Base64NoPad

-- | encode the input 'ByteString' to 'Multibase' via the 'Base64Pad' codec
encodeBase64PadToMultibase :: ByteString -> Multibase
encodeBase64PadToMultibase = encodingToMultibase_ $ Proxy @Base64Pad

-- | encode the input 'Text' to 'Multibase' via the 'Base64Pad' codec
encodeTextInBase64PadToMultibase :: Text -> Multibase
encodeTextInBase64PadToMultibase = encodingTextToMultibase_ $ Proxy @Base64Pad

-- | encode the input 'ByteString' to 'Multibase' via the 'Base64UrlNoPad' codec
encodeBase64UrlNoPadToMultibase :: ByteString -> Multibase
encodeBase64UrlNoPadToMultibase = encodingToMultibase_ $ Proxy @Base64UrlNoPad

-- | encode the input 'Text' to 'Multibase' via the 'Base64UrlNoPad' codec
encodeTextInBase64UrlNoPadToMultibase :: Text -> Multibase
encodeTextInBase64UrlNoPadToMultibase = encodingTextToMultibase_ $ Proxy @Base64UrlNoPad

-- | encode the input 'ByteString' to 'Multibase' via the 'Base64urlPad' codec
encodeBase64urlPadToMultibase :: ByteString -> Multibase
encodeBase64urlPadToMultibase = encodingToMultibase_ $ Proxy @Base64urlPad

-- | encode the input 'Text' to 'Multibase' via the 'Base64urlPad' codec
encodeTextInBase64urlPadToMultibase :: Text -> Multibase
encodeTextInBase64urlPadToMultibase = encodingTextToMultibase_ $ Proxy @Base64urlPad

-- | encode the input 'ByteString' to 'Multibase' via the 'Proquint' codec
encodeProquintToMultibase :: ByteString -> Multibase
encodeProquintToMultibase = encodingToMultibase_ $ Proxy @Proquint

-- | encode the input 'Text' to 'Multibase' via the 'Proquint' codec
encodeTextInProquintToMultibase :: Text -> Multibase
encodeTextInProquintToMultibase = encodingTextToMultibase_ $ Proxy @Proquint

-- | encode the input 'ByteString' to 'Multibase' via the 'Base256Emoji' codec
encodeBase256EmojiToMultibase :: ByteString -> Multibase
encodeBase256EmojiToMultibase = encodingToMultibase_ $ Proxy @Base256Emoji

-- | encode the input 'Text' to 'Multibase' via the 'Base256Emoji' codec
encodeTextInBase256EmojiToMultibase :: Text -> Multibase
encodeTextInBase256EmojiToMultibase = encodingTextToMultibase_ $ Proxy @Base256Emoji