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

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


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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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