sjsonnew.CaseClassFormats.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of sjson-new-core_2.13 Show documentation
A Scala library for JSON (de)serialization
The newest version!
// auto-generated by sbt-boilerplate
/*
 * Original implementation (C) 2009-2011 Debasish Ghosh
 * Adapted and extended in 2011 by Mathias Doenitz
 * Adapted and extended in 2016 by Eugene Yokota
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package sjsonnew

trait CaseClassFormats {

  // simple alias for reduced verbosity
  private[this] type JF[A] = JsonFormat[A]
  private[this] type K[A] = JsonKeyWriter[A]


  // The 1-arity case. Hand-rolled because of sbt/sbt-boilerplate#23

  def caseClass[K1: K, A1: JF, Z](applyFunc: A1 => Z, unapplyFunc: Z => Option[A1])(key1: K1): JF[Z] =
    caseClass1[K1, A1, Z](applyFunc, unapplyFunc)(key1)

  def caseClassArray[A1: JF, Z](applyFunc: A1 => Z, unapplyFunc: Z => Option[A1]): JF[Z] =
    caseClassArray1[A1, Z](applyFunc, unapplyFunc)

  def caseClass1[K1, A1, Z](applyFunc: A1 => Z, unapplyFunc: Z => Option[A1])(key1: K1)(
      implicit A1: JF[A1], K1: K[K1]
  ): JF[Z] =
    new JsonFormat[Z] {
      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
        case None     => deserializationError("Expected JsObject but found None")
        case Some(js) =>
          unbuilder.beginObject(js)
          val z = applyFunc(unbuilder.readField[A1](K1.write(key1)))
          unbuilder.endObject()
          z
      }

      def write[J](obj: Z, builder: Builder[J]): Unit = {
        val t = unapplyFunc(obj).get
        builder.beginObject()
        builder.addField(K1.write(key1), t)
        builder.endObject()
      }
    }

  def caseClassArray1[A1, Z](applyFunc: A1 => Z, unapplyFunc: Z => Option[A1])(implicit A1: JF[A1]): JF[Z] =
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case None     => applyFunc(A1.read(None, unbuilder))
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder))
            unbuilder.endArray()
            xs
        }
    }


  def caseClass[K1: K, K2: K, A1: JF, A2: JF, Z](applyFunc: (A1, A2) => Z, unapplyFunc: Z => Option[(A1, A2)])(key1: K1, key2: K2): JF[Z] =
    caseClass2[K1, K2, A1, A2, Z](applyFunc, unapplyFunc)(key1, key2)

  def caseClassArray[A1: JF, A2: JF, Z](applyFunc: (A1, A2) => Z, unapplyFunc: Z => Option[(A1, A2)]): JF[Z] =
    caseClassArray2[A1, A2, Z](applyFunc, unapplyFunc)

  def caseClass2[K1, K2, A1, A2, Z](applyFunc: (A1, A2) => Z, unapplyFunc: Z => Option[(A1, A2)])(key1: K1, key2: K2)(implicit A1: JF[A1], A2: JF[A2], K1: K[K1], K2: K[K2]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.endObject()
    }
  }

  def caseClassArray2[A1, A2, Z](applyFunc: (A1, A2) => Z, unapplyFunc: Z => Option[(A1, A2)])(implicit A1: JF[A1], A2: JF[A2]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, A1: JF, A2: JF, A3: JF, Z](applyFunc: (A1, A2, A3) => Z, unapplyFunc: Z => Option[(A1, A2, A3)])(key1: K1, key2: K2, key3: K3): JF[Z] =
    caseClass3[K1, K2, K3, A1, A2, A3, Z](applyFunc, unapplyFunc)(key1, key2, key3)

  def caseClassArray[A1: JF, A2: JF, A3: JF, Z](applyFunc: (A1, A2, A3) => Z, unapplyFunc: Z => Option[(A1, A2, A3)]): JF[Z] =
    caseClassArray3[A1, A2, A3, Z](applyFunc, unapplyFunc)

  def caseClass3[K1, K2, K3, A1, A2, A3, Z](applyFunc: (A1, A2, A3) => Z, unapplyFunc: Z => Option[(A1, A2, A3)])(key1: K1, key2: K2, key3: K3)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], K1: K[K1], K2: K[K2], K3: K[K3]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.endObject()
    }
  }

  def caseClassArray3[A1, A2, A3, Z](applyFunc: (A1, A2, A3) => Z, unapplyFunc: Z => Option[(A1, A2, A3)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, A1: JF, A2: JF, A3: JF, A4: JF, Z](applyFunc: (A1, A2, A3, A4) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4)])(key1: K1, key2: K2, key3: K3, key4: K4): JF[Z] =
    caseClass4[K1, K2, K3, K4, A1, A2, A3, A4, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, Z](applyFunc: (A1, A2, A3, A4) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4)]): JF[Z] =
    caseClassArray4[A1, A2, A3, A4, Z](applyFunc, unapplyFunc)

  def caseClass4[K1, K2, K3, K4, A1, A2, A3, A4, Z](applyFunc: (A1, A2, A3, A4) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4)])(key1: K1, key2: K2, key3: K3, key4: K4)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.endObject()
    }
  }

  def caseClassArray4[A1, A2, A3, A4, Z](applyFunc: (A1, A2, A3, A4) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, Z](applyFunc: (A1, A2, A3, A4, A5) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5): JF[Z] =
    caseClass5[K1, K2, K3, K4, K5, A1, A2, A3, A4, A5, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, Z](applyFunc: (A1, A2, A3, A4, A5) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5)]): JF[Z] =
    caseClassArray5[A1, A2, A3, A4, A5, Z](applyFunc, unapplyFunc)

  def caseClass5[K1, K2, K3, K4, K5, A1, A2, A3, A4, A5, Z](applyFunc: (A1, A2, A3, A4, A5) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.endObject()
    }
  }

  def caseClassArray5[A1, A2, A3, A4, A5, Z](applyFunc: (A1, A2, A3, A4, A5) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6): JF[Z] =
    caseClass6[K1, K2, K3, K4, K5, K6, A1, A2, A3, A4, A5, A6, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6)]): JF[Z] =
    caseClassArray6[A1, A2, A3, A4, A5, A6, Z](applyFunc, unapplyFunc)

  def caseClass6[K1, K2, K3, K4, K5, K6, A1, A2, A3, A4, A5, A6, Z](applyFunc: (A1, A2, A3, A4, A5, A6) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.endObject()
    }
  }

  def caseClassArray6[A1, A2, A3, A4, A5, A6, Z](applyFunc: (A1, A2, A3, A4, A5, A6) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7): JF[Z] =
    caseClass7[K1, K2, K3, K4, K5, K6, K7, A1, A2, A3, A4, A5, A6, A7, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7)]): JF[Z] =
    caseClassArray7[A1, A2, A3, A4, A5, A6, A7, Z](applyFunc, unapplyFunc)

  def caseClass7[K1, K2, K3, K4, K5, K6, K7, A1, A2, A3, A4, A5, A6, A7, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.endObject()
    }
  }

  def caseClassArray7[A1, A2, A3, A4, A5, A6, A7, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8): JF[Z] =
    caseClass8[K1, K2, K3, K4, K5, K6, K7, K8, A1, A2, A3, A4, A5, A6, A7, A8, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8)]): JF[Z] =
    caseClassArray8[A1, A2, A3, A4, A5, A6, A7, A8, Z](applyFunc, unapplyFunc)

  def caseClass8[K1, K2, K3, K4, K5, K6, K7, K8, A1, A2, A3, A4, A5, A6, A7, A8, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.endObject()
    }
  }

  def caseClassArray8[A1, A2, A3, A4, A5, A6, A7, A8, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9): JF[Z] =
    caseClass9[K1, K2, K3, K4, K5, K6, K7, K8, K9, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9)]): JF[Z] =
    caseClassArray9[A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](applyFunc, unapplyFunc)

  def caseClass9[K1, K2, K3, K4, K5, K6, K7, K8, K9, A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.endObject()
    }
  }

  def caseClassArray9[A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10): JF[Z] =
    caseClass10[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)]): JF[Z] =
    caseClassArray10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](applyFunc, unapplyFunc)

  def caseClass10[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.endObject()
    }
  }

  def caseClassArray10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11): JF[Z] =
    caseClass11[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)]): JF[Z] =
    caseClassArray11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](applyFunc, unapplyFunc)

  def caseClass11[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.endObject()
    }
  }

  def caseClassArray11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, K12: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12): JF[Z] =
    caseClass12[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)]): JF[Z] =
    caseClassArray12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](applyFunc, unapplyFunc)

  def caseClass12[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11], K12: K[K12]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11)), unbuilder.readField[A12](K12.write(key12))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.addField(K12.write(key12), t._12)
      builder.endObject()
    }
  }

  def caseClassArray12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        A12.write(x._12, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val a12 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder), A12.read(Some(a12), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder), A12.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, K12: K, K13: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13): JF[Z] =
    caseClass13[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)]): JF[Z] =
    caseClassArray13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](applyFunc, unapplyFunc)

  def caseClass13[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11], K12: K[K12], K13: K[K13]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11)), unbuilder.readField[A12](K12.write(key12)), unbuilder.readField[A13](K13.write(key13))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.addField(K12.write(key12), t._12)
      builder.addField(K13.write(key13), t._13)
      builder.endObject()
    }
  }

  def caseClassArray13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        A12.write(x._12, builder)
        A13.write(x._13, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val a12 = unbuilder.nextElement
            val a13 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder), A12.read(Some(a12), unbuilder), A13.read(Some(a13), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder), A12.read(None, unbuilder), A13.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, K12: K, K13: K, K14: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14): JF[Z] =
    caseClass14[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13, key14)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)]): JF[Z] =
    caseClassArray14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](applyFunc, unapplyFunc)

  def caseClass14[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11], K12: K[K12], K13: K[K13], K14: K[K14]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11)), unbuilder.readField[A12](K12.write(key12)), unbuilder.readField[A13](K13.write(key13)), unbuilder.readField[A14](K14.write(key14))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.addField(K12.write(key12), t._12)
      builder.addField(K13.write(key13), t._13)
      builder.addField(K14.write(key14), t._14)
      builder.endObject()
    }
  }

  def caseClassArray14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        A12.write(x._12, builder)
        A13.write(x._13, builder)
        A14.write(x._14, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val a12 = unbuilder.nextElement
            val a13 = unbuilder.nextElement
            val a14 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder), A12.read(Some(a12), unbuilder), A13.read(Some(a13), unbuilder), A14.read(Some(a14), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder), A12.read(None, unbuilder), A13.read(None, unbuilder), A14.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, K12: K, K13: K, K14: K, K15: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15): JF[Z] =
    caseClass15[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13, key14, key15)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)]): JF[Z] =
    caseClassArray15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](applyFunc, unapplyFunc)

  def caseClass15[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11], K12: K[K12], K13: K[K13], K14: K[K14], K15: K[K15]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11)), unbuilder.readField[A12](K12.write(key12)), unbuilder.readField[A13](K13.write(key13)), unbuilder.readField[A14](K14.write(key14)), unbuilder.readField[A15](K15.write(key15))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.addField(K12.write(key12), t._12)
      builder.addField(K13.write(key13), t._13)
      builder.addField(K14.write(key14), t._14)
      builder.addField(K15.write(key15), t._15)
      builder.endObject()
    }
  }

  def caseClassArray15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        A12.write(x._12, builder)
        A13.write(x._13, builder)
        A14.write(x._14, builder)
        A15.write(x._15, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val a12 = unbuilder.nextElement
            val a13 = unbuilder.nextElement
            val a14 = unbuilder.nextElement
            val a15 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder), A12.read(Some(a12), unbuilder), A13.read(Some(a13), unbuilder), A14.read(Some(a14), unbuilder), A15.read(Some(a15), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder), A12.read(None, unbuilder), A13.read(None, unbuilder), A14.read(None, unbuilder), A15.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, K12: K, K13: K, K14: K, K15: K, K16: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16): JF[Z] =
    caseClass16[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13, key14, key15, key16)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)]): JF[Z] =
    caseClassArray16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](applyFunc, unapplyFunc)

  def caseClass16[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11], K12: K[K12], K13: K[K13], K14: K[K14], K15: K[K15], K16: K[K16]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11)), unbuilder.readField[A12](K12.write(key12)), unbuilder.readField[A13](K13.write(key13)), unbuilder.readField[A14](K14.write(key14)), unbuilder.readField[A15](K15.write(key15)), unbuilder.readField[A16](K16.write(key16))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.addField(K12.write(key12), t._12)
      builder.addField(K13.write(key13), t._13)
      builder.addField(K14.write(key14), t._14)
      builder.addField(K15.write(key15), t._15)
      builder.addField(K16.write(key16), t._16)
      builder.endObject()
    }
  }

  def caseClassArray16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        A12.write(x._12, builder)
        A13.write(x._13, builder)
        A14.write(x._14, builder)
        A15.write(x._15, builder)
        A16.write(x._16, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val a12 = unbuilder.nextElement
            val a13 = unbuilder.nextElement
            val a14 = unbuilder.nextElement
            val a15 = unbuilder.nextElement
            val a16 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder), A12.read(Some(a12), unbuilder), A13.read(Some(a13), unbuilder), A14.read(Some(a14), unbuilder), A15.read(Some(a15), unbuilder), A16.read(Some(a16), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder), A12.read(None, unbuilder), A13.read(None, unbuilder), A14.read(None, unbuilder), A15.read(None, unbuilder), A16.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, K12: K, K13: K, K14: K, K15: K, K16: K, K17: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17): JF[Z] =
    caseClass17[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13, key14, key15, key16, key17)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)]): JF[Z] =
    caseClassArray17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](applyFunc, unapplyFunc)

  def caseClass17[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11], K12: K[K12], K13: K[K13], K14: K[K14], K15: K[K15], K16: K[K16], K17: K[K17]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11)), unbuilder.readField[A12](K12.write(key12)), unbuilder.readField[A13](K13.write(key13)), unbuilder.readField[A14](K14.write(key14)), unbuilder.readField[A15](K15.write(key15)), unbuilder.readField[A16](K16.write(key16)), unbuilder.readField[A17](K17.write(key17))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.addField(K12.write(key12), t._12)
      builder.addField(K13.write(key13), t._13)
      builder.addField(K14.write(key14), t._14)
      builder.addField(K15.write(key15), t._15)
      builder.addField(K16.write(key16), t._16)
      builder.addField(K17.write(key17), t._17)
      builder.endObject()
    }
  }

  def caseClassArray17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        A12.write(x._12, builder)
        A13.write(x._13, builder)
        A14.write(x._14, builder)
        A15.write(x._15, builder)
        A16.write(x._16, builder)
        A17.write(x._17, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val a12 = unbuilder.nextElement
            val a13 = unbuilder.nextElement
            val a14 = unbuilder.nextElement
            val a15 = unbuilder.nextElement
            val a16 = unbuilder.nextElement
            val a17 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder), A12.read(Some(a12), unbuilder), A13.read(Some(a13), unbuilder), A14.read(Some(a14), unbuilder), A15.read(Some(a15), unbuilder), A16.read(Some(a16), unbuilder), A17.read(Some(a17), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder), A12.read(None, unbuilder), A13.read(None, unbuilder), A14.read(None, unbuilder), A15.read(None, unbuilder), A16.read(None, unbuilder), A17.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, K12: K, K13: K, K14: K, K15: K, K16: K, K17: K, K18: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, A18: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17, key18: K18): JF[Z] =
    caseClass18[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13, key14, key15, key16, key17, key18)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, A18: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)]): JF[Z] =
    caseClassArray18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](applyFunc, unapplyFunc)

  def caseClass18[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17, key18: K18)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17], A18: JF[A18], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11], K12: K[K12], K13: K[K13], K14: K[K14], K15: K[K15], K16: K[K16], K17: K[K17], K18: K[K18]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11)), unbuilder.readField[A12](K12.write(key12)), unbuilder.readField[A13](K13.write(key13)), unbuilder.readField[A14](K14.write(key14)), unbuilder.readField[A15](K15.write(key15)), unbuilder.readField[A16](K16.write(key16)), unbuilder.readField[A17](K17.write(key17)), unbuilder.readField[A18](K18.write(key18))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.addField(K12.write(key12), t._12)
      builder.addField(K13.write(key13), t._13)
      builder.addField(K14.write(key14), t._14)
      builder.addField(K15.write(key15), t._15)
      builder.addField(K16.write(key16), t._16)
      builder.addField(K17.write(key17), t._17)
      builder.addField(K18.write(key18), t._18)
      builder.endObject()
    }
  }

  def caseClassArray18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17], A18: JF[A18]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        A12.write(x._12, builder)
        A13.write(x._13, builder)
        A14.write(x._14, builder)
        A15.write(x._15, builder)
        A16.write(x._16, builder)
        A17.write(x._17, builder)
        A18.write(x._18, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val a12 = unbuilder.nextElement
            val a13 = unbuilder.nextElement
            val a14 = unbuilder.nextElement
            val a15 = unbuilder.nextElement
            val a16 = unbuilder.nextElement
            val a17 = unbuilder.nextElement
            val a18 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder), A12.read(Some(a12), unbuilder), A13.read(Some(a13), unbuilder), A14.read(Some(a14), unbuilder), A15.read(Some(a15), unbuilder), A16.read(Some(a16), unbuilder), A17.read(Some(a17), unbuilder), A18.read(Some(a18), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder), A12.read(None, unbuilder), A13.read(None, unbuilder), A14.read(None, unbuilder), A15.read(None, unbuilder), A16.read(None, unbuilder), A17.read(None, unbuilder), A18.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, K12: K, K13: K, K14: K, K15: K, K16: K, K17: K, K18: K, K19: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, A18: JF, A19: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17, key18: K18, key19: K19): JF[Z] =
    caseClass19[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13, key14, key15, key16, key17, key18, key19)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, A18: JF, A19: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)]): JF[Z] =
    caseClassArray19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](applyFunc, unapplyFunc)

  def caseClass19[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17, key18: K18, key19: K19)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17], A18: JF[A18], A19: JF[A19], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11], K12: K[K12], K13: K[K13], K14: K[K14], K15: K[K15], K16: K[K16], K17: K[K17], K18: K[K18], K19: K[K19]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11)), unbuilder.readField[A12](K12.write(key12)), unbuilder.readField[A13](K13.write(key13)), unbuilder.readField[A14](K14.write(key14)), unbuilder.readField[A15](K15.write(key15)), unbuilder.readField[A16](K16.write(key16)), unbuilder.readField[A17](K17.write(key17)), unbuilder.readField[A18](K18.write(key18)), unbuilder.readField[A19](K19.write(key19))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.addField(K12.write(key12), t._12)
      builder.addField(K13.write(key13), t._13)
      builder.addField(K14.write(key14), t._14)
      builder.addField(K15.write(key15), t._15)
      builder.addField(K16.write(key16), t._16)
      builder.addField(K17.write(key17), t._17)
      builder.addField(K18.write(key18), t._18)
      builder.addField(K19.write(key19), t._19)
      builder.endObject()
    }
  }

  def caseClassArray19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17], A18: JF[A18], A19: JF[A19]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        A12.write(x._12, builder)
        A13.write(x._13, builder)
        A14.write(x._14, builder)
        A15.write(x._15, builder)
        A16.write(x._16, builder)
        A17.write(x._17, builder)
        A18.write(x._18, builder)
        A19.write(x._19, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val a12 = unbuilder.nextElement
            val a13 = unbuilder.nextElement
            val a14 = unbuilder.nextElement
            val a15 = unbuilder.nextElement
            val a16 = unbuilder.nextElement
            val a17 = unbuilder.nextElement
            val a18 = unbuilder.nextElement
            val a19 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder), A12.read(Some(a12), unbuilder), A13.read(Some(a13), unbuilder), A14.read(Some(a14), unbuilder), A15.read(Some(a15), unbuilder), A16.read(Some(a16), unbuilder), A17.read(Some(a17), unbuilder), A18.read(Some(a18), unbuilder), A19.read(Some(a19), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder), A12.read(None, unbuilder), A13.read(None, unbuilder), A14.read(None, unbuilder), A15.read(None, unbuilder), A16.read(None, unbuilder), A17.read(None, unbuilder), A18.read(None, unbuilder), A19.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, K12: K, K13: K, K14: K, K15: K, K16: K, K17: K, K18: K, K19: K, K20: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, A18: JF, A19: JF, A20: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17, key18: K18, key19: K19, key20: K20): JF[Z] =
    caseClass20[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13, key14, key15, key16, key17, key18, key19, key20)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, A18: JF, A19: JF, A20: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)]): JF[Z] =
    caseClassArray20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](applyFunc, unapplyFunc)

  def caseClass20[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17, key18: K18, key19: K19, key20: K20)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17], A18: JF[A18], A19: JF[A19], A20: JF[A20], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11], K12: K[K12], K13: K[K13], K14: K[K14], K15: K[K15], K16: K[K16], K17: K[K17], K18: K[K18], K19: K[K19], K20: K[K20]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11)), unbuilder.readField[A12](K12.write(key12)), unbuilder.readField[A13](K13.write(key13)), unbuilder.readField[A14](K14.write(key14)), unbuilder.readField[A15](K15.write(key15)), unbuilder.readField[A16](K16.write(key16)), unbuilder.readField[A17](K17.write(key17)), unbuilder.readField[A18](K18.write(key18)), unbuilder.readField[A19](K19.write(key19)), unbuilder.readField[A20](K20.write(key20))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.addField(K12.write(key12), t._12)
      builder.addField(K13.write(key13), t._13)
      builder.addField(K14.write(key14), t._14)
      builder.addField(K15.write(key15), t._15)
      builder.addField(K16.write(key16), t._16)
      builder.addField(K17.write(key17), t._17)
      builder.addField(K18.write(key18), t._18)
      builder.addField(K19.write(key19), t._19)
      builder.addField(K20.write(key20), t._20)
      builder.endObject()
    }
  }

  def caseClassArray20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17], A18: JF[A18], A19: JF[A19], A20: JF[A20]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        A12.write(x._12, builder)
        A13.write(x._13, builder)
        A14.write(x._14, builder)
        A15.write(x._15, builder)
        A16.write(x._16, builder)
        A17.write(x._17, builder)
        A18.write(x._18, builder)
        A19.write(x._19, builder)
        A20.write(x._20, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val a12 = unbuilder.nextElement
            val a13 = unbuilder.nextElement
            val a14 = unbuilder.nextElement
            val a15 = unbuilder.nextElement
            val a16 = unbuilder.nextElement
            val a17 = unbuilder.nextElement
            val a18 = unbuilder.nextElement
            val a19 = unbuilder.nextElement
            val a20 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder), A12.read(Some(a12), unbuilder), A13.read(Some(a13), unbuilder), A14.read(Some(a14), unbuilder), A15.read(Some(a15), unbuilder), A16.read(Some(a16), unbuilder), A17.read(Some(a17), unbuilder), A18.read(Some(a18), unbuilder), A19.read(Some(a19), unbuilder), A20.read(Some(a20), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder), A12.read(None, unbuilder), A13.read(None, unbuilder), A14.read(None, unbuilder), A15.read(None, unbuilder), A16.read(None, unbuilder), A17.read(None, unbuilder), A18.read(None, unbuilder), A19.read(None, unbuilder), A20.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, K12: K, K13: K, K14: K, K15: K, K16: K, K17: K, K18: K, K19: K, K20: K, K21: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, A18: JF, A19: JF, A20: JF, A21: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17, key18: K18, key19: K19, key20: K20, key21: K21): JF[Z] =
    caseClass21[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K20, K21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13, key14, key15, key16, key17, key18, key19, key20, key21)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, A18: JF, A19: JF, A20: JF, A21: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]): JF[Z] =
    caseClassArray21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](applyFunc, unapplyFunc)

  def caseClass21[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K20, K21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17, key18: K18, key19: K19, key20: K20, key21: K21)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17], A18: JF[A18], A19: JF[A19], A20: JF[A20], A21: JF[A21], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11], K12: K[K12], K13: K[K13], K14: K[K14], K15: K[K15], K16: K[K16], K17: K[K17], K18: K[K18], K19: K[K19], K20: K[K20], K21: K[K21]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11)), unbuilder.readField[A12](K12.write(key12)), unbuilder.readField[A13](K13.write(key13)), unbuilder.readField[A14](K14.write(key14)), unbuilder.readField[A15](K15.write(key15)), unbuilder.readField[A16](K16.write(key16)), unbuilder.readField[A17](K17.write(key17)), unbuilder.readField[A18](K18.write(key18)), unbuilder.readField[A19](K19.write(key19)), unbuilder.readField[A20](K20.write(key20)), unbuilder.readField[A21](K21.write(key21))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.addField(K12.write(key12), t._12)
      builder.addField(K13.write(key13), t._13)
      builder.addField(K14.write(key14), t._14)
      builder.addField(K15.write(key15), t._15)
      builder.addField(K16.write(key16), t._16)
      builder.addField(K17.write(key17), t._17)
      builder.addField(K18.write(key18), t._18)
      builder.addField(K19.write(key19), t._19)
      builder.addField(K20.write(key20), t._20)
      builder.addField(K21.write(key21), t._21)
      builder.endObject()
    }
  }

  def caseClassArray21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17], A18: JF[A18], A19: JF[A19], A20: JF[A20], A21: JF[A21]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        A12.write(x._12, builder)
        A13.write(x._13, builder)
        A14.write(x._14, builder)
        A15.write(x._15, builder)
        A16.write(x._16, builder)
        A17.write(x._17, builder)
        A18.write(x._18, builder)
        A19.write(x._19, builder)
        A20.write(x._20, builder)
        A21.write(x._21, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val a12 = unbuilder.nextElement
            val a13 = unbuilder.nextElement
            val a14 = unbuilder.nextElement
            val a15 = unbuilder.nextElement
            val a16 = unbuilder.nextElement
            val a17 = unbuilder.nextElement
            val a18 = unbuilder.nextElement
            val a19 = unbuilder.nextElement
            val a20 = unbuilder.nextElement
            val a21 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder), A12.read(Some(a12), unbuilder), A13.read(Some(a13), unbuilder), A14.read(Some(a14), unbuilder), A15.read(Some(a15), unbuilder), A16.read(Some(a16), unbuilder), A17.read(Some(a17), unbuilder), A18.read(Some(a18), unbuilder), A19.read(Some(a19), unbuilder), A20.read(Some(a20), unbuilder), A21.read(Some(a21), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder), A12.read(None, unbuilder), A13.read(None, unbuilder), A14.read(None, unbuilder), A15.read(None, unbuilder), A16.read(None, unbuilder), A17.read(None, unbuilder), A18.read(None, unbuilder), A19.read(None, unbuilder), A20.read(None, unbuilder), A21.read(None, unbuilder))
        }
    }
  }

  def caseClass[K1: K, K2: K, K3: K, K4: K, K5: K, K6: K, K7: K, K8: K, K9: K, K10: K, K11: K, K12: K, K13: K, K14: K, K15: K, K16: K, K17: K, K18: K, K19: K, K20: K, K21: K, K22: K, A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, A18: JF, A19: JF, A20: JF, A21: JF, A22: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17, key18: K18, key19: K19, key20: K20, key21: K21, key22: K22): JF[Z] =
    caseClass22[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K20, K21, K22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, Z](applyFunc, unapplyFunc)(key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13, key14, key15, key16, key17, key18, key19, key20, key21, key22)

  def caseClassArray[A1: JF, A2: JF, A3: JF, A4: JF, A5: JF, A6: JF, A7: JF, A8: JF, A9: JF, A10: JF, A11: JF, A12: JF, A13: JF, A14: JF, A15: JF, A16: JF, A17: JF, A18: JF, A19: JF, A20: JF, A21: JF, A22: JF, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)]): JF[Z] =
    caseClassArray22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, Z](applyFunc, unapplyFunc)

  def caseClass22[K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K20, K21, K22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)])(key1: K1, key2: K2, key3: K3, key4: K4, key5: K5, key6: K6, key7: K7, key8: K8, key9: K9, key10: K10, key11: K11, key12: K12, key13: K13, key14: K14, key15: K15, key16: K16, key17: K17, key18: K18, key19: K19, key20: K20, key21: K21, key22: K22)(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17], A18: JF[A18], A19: JF[A19], A20: JF[A20], A21: JF[A21], A22: JF[A22], K1: K[K1], K2: K[K2], K3: K[K3], K4: K[K4], K5: K[K5], K6: K[K6], K7: K[K7], K8: K[K8], K9: K[K9], K10: K[K10], K11: K[K11], K12: K[K12], K13: K[K13], K14: K[K14], K15: K[K15], K16: K[K16], K17: K[K17], K18: K[K18], K19: K[K19], K20: K[K20], K21: K[K21], K22: K[K22]): JF[Z] = new JsonFormat[Z] {
    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z = jsOpt match {
      case Some(js) =>
        unbuilder.beginObject(js)
        val z = applyFunc(
          unbuilder.readField[A1](K1.write(key1)), unbuilder.readField[A2](K2.write(key2)), unbuilder.readField[A3](K3.write(key3)), unbuilder.readField[A4](K4.write(key4)), unbuilder.readField[A5](K5.write(key5)), unbuilder.readField[A6](K6.write(key6)), unbuilder.readField[A7](K7.write(key7)), unbuilder.readField[A8](K8.write(key8)), unbuilder.readField[A9](K9.write(key9)), unbuilder.readField[A10](K10.write(key10)), unbuilder.readField[A11](K11.write(key11)), unbuilder.readField[A12](K12.write(key12)), unbuilder.readField[A13](K13.write(key13)), unbuilder.readField[A14](K14.write(key14)), unbuilder.readField[A15](K15.write(key15)), unbuilder.readField[A16](K16.write(key16)), unbuilder.readField[A17](K17.write(key17)), unbuilder.readField[A18](K18.write(key18)), unbuilder.readField[A19](K19.write(key19)), unbuilder.readField[A20](K20.write(key20)), unbuilder.readField[A21](K21.write(key21)), unbuilder.readField[A22](K22.write(key22))
        )
        unbuilder.endObject()
        z
      case None =>
        deserializationError("Expected JsObject but found None")
    }

    def write[J](obj: Z, builder: Builder[J]): Unit = {
      val t = unapplyFunc(obj).get
      builder.beginObject()
      builder.addField(K1.write(key1), t._1)
      builder.addField(K2.write(key2), t._2)
      builder.addField(K3.write(key3), t._3)
      builder.addField(K4.write(key4), t._4)
      builder.addField(K5.write(key5), t._5)
      builder.addField(K6.write(key6), t._6)
      builder.addField(K7.write(key7), t._7)
      builder.addField(K8.write(key8), t._8)
      builder.addField(K9.write(key9), t._9)
      builder.addField(K10.write(key10), t._10)
      builder.addField(K11.write(key11), t._11)
      builder.addField(K12.write(key12), t._12)
      builder.addField(K13.write(key13), t._13)
      builder.addField(K14.write(key14), t._14)
      builder.addField(K15.write(key15), t._15)
      builder.addField(K16.write(key16), t._16)
      builder.addField(K17.write(key17), t._17)
      builder.addField(K18.write(key18), t._18)
      builder.addField(K19.write(key19), t._19)
      builder.addField(K20.write(key20), t._20)
      builder.addField(K21.write(key21), t._21)
      builder.addField(K22.write(key22), t._22)
      builder.endObject()
    }
  }

  def caseClassArray22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, Z](applyFunc: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) => Z, unapplyFunc: Z => Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)])(implicit A1: JF[A1], A2: JF[A2], A3: JF[A3], A4: JF[A4], A5: JF[A5], A6: JF[A6], A7: JF[A7], A8: JF[A8], A9: JF[A9], A10: JF[A10], A11: JF[A11], A12: JF[A12], A13: JF[A13], A14: JF[A14], A15: JF[A15], A16: JF[A16], A17: JF[A17], A18: JF[A18], A19: JF[A19], A20: JF[A20], A21: JF[A21], A22: JF[A22]): JF[Z] = {
    new JsonFormat[Z] {
      def write[J](t: Z, builder: Builder[J]): Unit = {
        val x = unapplyFunc(t).get
        builder.beginArray()
        A1.write(x._1, builder)
        A2.write(x._2, builder)
        A3.write(x._3, builder)
        A4.write(x._4, builder)
        A5.write(x._5, builder)
        A6.write(x._6, builder)
        A7.write(x._7, builder)
        A8.write(x._8, builder)
        A9.write(x._9, builder)
        A10.write(x._10, builder)
        A11.write(x._11, builder)
        A12.write(x._12, builder)
        A13.write(x._13, builder)
        A14.write(x._14, builder)
        A15.write(x._15, builder)
        A16.write(x._16, builder)
        A17.write(x._17, builder)
        A18.write(x._18, builder)
        A19.write(x._19, builder)
        A20.write(x._20, builder)
        A21.write(x._21, builder)
        A22.write(x._22, builder)
        builder.endArray()
      }

      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): Z =
        jsOpt match {
          case Some(js) =>
            unbuilder.beginArray(js)
            val a1 = unbuilder.nextElement
            val a2 = unbuilder.nextElement
            val a3 = unbuilder.nextElement
            val a4 = unbuilder.nextElement
            val a5 = unbuilder.nextElement
            val a6 = unbuilder.nextElement
            val a7 = unbuilder.nextElement
            val a8 = unbuilder.nextElement
            val a9 = unbuilder.nextElement
            val a10 = unbuilder.nextElement
            val a11 = unbuilder.nextElement
            val a12 = unbuilder.nextElement
            val a13 = unbuilder.nextElement
            val a14 = unbuilder.nextElement
            val a15 = unbuilder.nextElement
            val a16 = unbuilder.nextElement
            val a17 = unbuilder.nextElement
            val a18 = unbuilder.nextElement
            val a19 = unbuilder.nextElement
            val a20 = unbuilder.nextElement
            val a21 = unbuilder.nextElement
            val a22 = unbuilder.nextElement
            val xs = applyFunc(A1.read(Some(a1), unbuilder), A2.read(Some(a2), unbuilder), A3.read(Some(a3), unbuilder), A4.read(Some(a4), unbuilder), A5.read(Some(a5), unbuilder), A6.read(Some(a6), unbuilder), A7.read(Some(a7), unbuilder), A8.read(Some(a8), unbuilder), A9.read(Some(a9), unbuilder), A10.read(Some(a10), unbuilder), A11.read(Some(a11), unbuilder), A12.read(Some(a12), unbuilder), A13.read(Some(a13), unbuilder), A14.read(Some(a14), unbuilder), A15.read(Some(a15), unbuilder), A16.read(Some(a16), unbuilder), A17.read(Some(a17), unbuilder), A18.read(Some(a18), unbuilder), A19.read(Some(a19), unbuilder), A20.read(Some(a20), unbuilder), A21.read(Some(a21), unbuilder), A22.read(Some(a22), unbuilder))
            unbuilder.endArray()
            xs
          case None =>
            applyFunc(A1.read(None, unbuilder), A2.read(None, unbuilder), A3.read(None, unbuilder), A4.read(None, unbuilder), A5.read(None, unbuilder), A6.read(None, unbuilder), A7.read(None, unbuilder), A8.read(None, unbuilder), A9.read(None, unbuilder), A10.read(None, unbuilder), A11.read(None, unbuilder), A12.read(None, unbuilder), A13.read(None, unbuilder), A14.read(None, unbuilder), A15.read(None, unbuilder), A16.read(None, unbuilder), A17.read(None, unbuilder), A18.read(None, unbuilder), A19.read(None, unbuilder), A20.read(None, unbuilder), A21.read(None, unbuilder), A22.read(None, unbuilder))
        }
    }
  }

}