{-# 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.MultibaseShort 
  ( MultibaseShort(..)
  , module Data.Multibase.Types.MultibaseShort
  ) 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
decodeMultibaseShort :: MultibaseShort -> Either MbDecodeFailure ByteStringShort
decodeMultibaseShort = decodingMultibase

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


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

encodeToMultibaseShortWith :: MbAlgorithm -> ByteStringShort -> MultibaseBytesShort
encodeToMultibaseShortWith = encodingToMultibase

encodeTextToMultibaseShortWith :: MbAlgorithm -> TextShort -> MultibaseBytesShort
encodeTextToMultibaseShortWith = encodingTextToMultibase


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

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'IdentityBase' codec
encodeIdentityBaseToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeIdentityBaseToMultibaseShort = encodingToMultibase_ $ Proxy @IdentityBase

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'IdentityBase' codec
encodeTextInIdentityBaseToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInIdentityBaseToMultibaseShort = encodingTextToMultibase_ $ Proxy @IdentityBase

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base2' codec
encodeBase2ToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase2ToMultibaseShort = encodingToMultibase_ $ Proxy @Base2

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base2' codec
encodeTextInBase2ToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase2ToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base2

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base8' codec
encodeBase8ToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase8ToMultibaseShort = encodingToMultibase_ $ Proxy @Base8

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base8' codec
encodeTextInBase8ToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase8ToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base8

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base10' codec
encodeBase10ToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase10ToMultibaseShort = encodingToMultibase_ $ Proxy @Base10

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base10' codec
encodeTextInBase10ToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase10ToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base10

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base16Lower' codec
encodeBase16LowerToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase16LowerToMultibaseShort = encodingToMultibase_ $ Proxy @Base16Lower

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base16Lower' codec
encodeTextInBase16LowerToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase16LowerToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base16Lower

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base16Upper' codec
encodeBase16UpperToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase16UpperToMultibaseShort = encodingToMultibase_ $ Proxy @Base16Upper

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base16Upper' codec
encodeTextInBase16UpperToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase16UpperToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base16Upper

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base32HexNoPadLower' codec
encodeBase32HexNoPadLowerToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase32HexNoPadLowerToMultibaseShort = encodingToMultibase_ $ Proxy @Base32HexNoPadLower

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base32HexNoPadLower' codec
encodeTextInBase32HexNoPadLowerToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase32HexNoPadLowerToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base32HexNoPadLower

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base32HexNoPadUpper' codec
encodeBase32HexNoPadUpperToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase32HexNoPadUpperToMultibaseShort = encodingToMultibase_ $ Proxy @Base32HexNoPadUpper

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base32HexNoPadUpper' codec
encodeTextInBase32HexNoPadUpperToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase32HexNoPadUpperToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base32HexNoPadUpper

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base32HexPadLower' codec
encodeBase32HexPadLowerToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase32HexPadLowerToMultibaseShort = encodingToMultibase_ $ Proxy @Base32HexPadLower

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base32HexPadLower' codec
encodeTextInBase32HexPadLowerToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase32HexPadLowerToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base32HexPadLower

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base32HexPadUpper' codec
encodeBase32HexPadUpperToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase32HexPadUpperToMultibaseShort = encodingToMultibase_ $ Proxy @Base32HexPadUpper

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base32HexPadUpper' codec
encodeTextInBase32HexPadUpperToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase32HexPadUpperToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base32HexPadUpper

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base32NoPadLower' codec
encodeBase32NoPadLowerToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase32NoPadLowerToMultibaseShort = encodingToMultibase_ $ Proxy @Base32NoPadLower

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base32NoPadLower' codec
encodeTextInBase32NoPadLowerToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase32NoPadLowerToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base32NoPadLower

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base32NoPadUpper' codec
encodeBase32NoPadUpperToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase32NoPadUpperToMultibaseShort = encodingToMultibase_ $ Proxy @Base32NoPadUpper

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base32NoPadUpper' codec
encodeTextInBase32NoPadUpperToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase32NoPadUpperToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base32NoPadUpper

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base32PadLower' codec
encodeBase32PadLowerToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase32PadLowerToMultibaseShort = encodingToMultibase_ $ Proxy @Base32PadLower

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base32PadLower' codec
encodeTextInBase32PadLowerToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase32PadLowerToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base32PadLower

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base32PadUpper' codec
encodeBase32PadUpperToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase32PadUpperToMultibaseShort = encodingToMultibase_ $ Proxy @Base32PadUpper

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base32PadUpper' codec
encodeTextInBase32PadUpperToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase32PadUpperToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base32PadUpper

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base32z' codec
encodeBase32zToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase32zToMultibaseShort = encodingToMultibase_ $ Proxy @Base32z

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base32z' codec
encodeTextInBase32zToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase32zToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base32z

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base36Lower' codec
encodeBase36LowerToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase36LowerToMultibaseShort = encodingToMultibase_ $ Proxy @Base36Lower

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base36Lower' codec
encodeTextInBase36LowerToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase36LowerToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base36Lower

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base36Upper' codec
encodeBase36UpperToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase36UpperToMultibaseShort = encodingToMultibase_ $ Proxy @Base36Upper

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base36Upper' codec
encodeTextInBase36UpperToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase36UpperToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base36Upper

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base58Btc' codec
encodeBase58BtcToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase58BtcToMultibaseShort = encodingToMultibase_ $ Proxy @Base58Btc

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base58Btc' codec
encodeTextInBase58BtcToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase58BtcToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base58Btc

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base58Flickr' codec
encodeBase58FlickrToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase58FlickrToMultibaseShort = encodingToMultibase_ $ Proxy @Base58Flickr

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base58Flickr' codec
encodeTextInBase58FlickrToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase58FlickrToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base58Flickr

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base64NoPad' codec
encodeBase64NoPadToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase64NoPadToMultibaseShort = encodingToMultibase_ $ Proxy @Base64NoPad

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base64NoPad' codec
encodeTextInBase64NoPadToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase64NoPadToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base64NoPad

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base64Pad' codec
encodeBase64PadToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase64PadToMultibaseShort = encodingToMultibase_ $ Proxy @Base64Pad

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base64Pad' codec
encodeTextInBase64PadToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase64PadToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base64Pad

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base64UrlNoPad' codec
encodeBase64UrlNoPadToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase64UrlNoPadToMultibaseShort = encodingToMultibase_ $ Proxy @Base64UrlNoPad

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base64UrlNoPad' codec
encodeTextInBase64UrlNoPadToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase64UrlNoPadToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base64UrlNoPad

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base64urlPad' codec
encodeBase64urlPadToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase64urlPadToMultibaseShort = encodingToMultibase_ $ Proxy @Base64urlPad

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base64urlPad' codec
encodeTextInBase64urlPadToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase64urlPadToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base64urlPad

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Proquint' codec
encodeProquintToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeProquintToMultibaseShort = encodingToMultibase_ $ Proxy @Proquint

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Proquint' codec
encodeTextInProquintToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInProquintToMultibaseShort = encodingTextToMultibase_ $ Proxy @Proquint

-- | encode the input 'ByteStringShort' to 'MultibaseShort' via the 'Base256Emoji' codec
encodeBase256EmojiToMultibaseShort :: ByteStringShort -> MultibaseShort
encodeBase256EmojiToMultibaseShort = encodingToMultibase_ $ Proxy @Base256Emoji

-- | encode the input 'TextShort' to 'MultibaseShort' via the 'Base256Emoji' codec
encodeTextInBase256EmojiToMultibaseShort :: TextShort -> MultibaseShort
encodeTextInBase256EmojiToMultibaseShort = encodingTextToMultibase_ $ Proxy @Base256Emoji