SignedCodec

abstract def signature(bits: BitVector): Attempt[ByteVector]

abstract def signatureCodec: Codec[BitVector]

The codec to use for the signature portion of the encoded bits.

abstract def signingKey: SignatureKey

abstract def targetCodec: Codec[A]

Returns the underlying codec that is to be used before the signature is applied

final def !=(arg0: Any): Boolean

final def ##(): Int

def :+:[B](left: Codec[B]): CoproductCodecBuilder[:+:[B, :+:[A, CNil]], ::[Codec[B], ::[Codec[A], HNil]], :+:[B, :+:[A, CNil]]]

final def <~[B](codecB: Codec[B])(implicit ev: =:=[Unit, B]): Codec[A]

final def ==(arg0: Any): Boolean

final def >>~[B](f: (A) ⇒ Codec[B]): Codec[(A, B)]

def asDecoder: Decoder[A]

def asEncoder: Encoder[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def compact: Codec[A]

final def complete: Codec[A]

final def consume[B](f: (A) ⇒ Codec[B])(g: (B) ⇒ A): Codec[B]

def contramap[C](f: (C) ⇒ A): GenCodec[C, A]

final def decode(bits: BitVector): Attempt[DecodeResult[A]]

def decodeOnly[AA >: A]: Codec[AA]

final def decodeValue(bits: BitVector): Attempt[A]

final def downcast[B <: A](implicit tb: Typeable[B]): Codec[B]

final def dropLeft[B](codecB: Codec[B])(implicit ev: =:=[Unit, A]): Codec[B]

final def dropRight[B](codecB: Codec[B])(implicit ev: =:=[Unit, B]): Codec[A]

def econtramap[C](f: (C) ⇒ Attempt[A]): GenCodec[C, A]

def emap[C](f: (A) ⇒ Attempt[C]): GenCodec[A, C]

final def encode(a: A): Attempt[BitVector]

def encodeOnly: Codec[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def exmap[B](f: (A) ⇒ Attempt[B], g: (B) ⇒ Attempt[A]): Codec[B]

def finalize(): Unit

def flatMap[B](f: (A) ⇒ Decoder[B]): Decoder[B]

final def flatZip[B](f: (A) ⇒ Codec[B]): Codec[(A, B)]

final def flattenLeftPairs(implicit f: FlattenLeftPairs[A]): Codec[Out]

final def fuse[AA <: A, BB >: A](implicit ev: =:=[BB, AA]): Codec[BB]

final def getClass(): Class[_]

def hashCode(): Int

final def hlist: Codec[::[A, HNil]]

final def isInstanceOf[T0]: Boolean

def map[C](f: (A) ⇒ C): GenCodec[A, C]

final def narrow[B](f: (A) ⇒ Attempt[B], g: (B) ⇒ A): Codec[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def pairedWith[B](codecB: Codec[B]): Codec[(A, B)]

def pcontramap[C](f: (C) ⇒ Option[A]): GenCodec[C, A]

def sizeBound: SizeBound

final def synchronized[T0](arg0: ⇒ T0): T0

def toField[K]: Codec[FieldType[K, A]]

def toFieldWithContext[K <: Symbol](k: K): Codec[FieldType[K, A]]

def toString(): String

final def unit(zero: A): Codec[Unit]

final def upcast[B >: A](implicit ta: Typeable[A]): Codec[B]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def widen[B](f: (A) ⇒ B, g: (B) ⇒ Attempt[A]): Codec[B]

final def withContext(context: String): Codec[A]

final def withToString(str: ⇒ String): Codec[A]

final def xmap[B](f: (A) ⇒ B, g: (B) ⇒ A): Codec[B]

final def ~[B](codecB: Codec[B]): Codec[(A, B)]

final def ~>[B](codecB: Codec[B])(implicit ev: =:=[Unit, A]): Codec[B]