Type Members

1.  sealed case class CaseClass1[A, Z](field: Field[A], construct: (A) ⇒ Z, extractField: (Z) ⇒ A, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
2.  sealed case class CaseClass10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
3.  sealed case class CaseClass11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
4.  sealed case class CaseClass12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], field12: Field[A12], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, extractField12: (Z) ⇒ A12, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
5.  sealed case class CaseClass13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], field12: Field[A12], field13: Field[A13], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, extractField12: (Z) ⇒ A12, extractField13: (Z) ⇒ A13, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
6.  sealed case class CaseClass14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], field12: Field[A12], field13: Field[A13], field14: Field[A14], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, extractField12: (Z) ⇒ A12, extractField13: (Z) ⇒ A13, extractField14: (Z) ⇒ A14, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
7.  sealed case class CaseClass15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], field12: Field[A12], field13: Field[A13], field14: Field[A14], field15: Field[A15], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, extractField12: (Z) ⇒ A12, extractField13: (Z) ⇒ A13, extractField14: (Z) ⇒ A14, extractField15: (Z) ⇒ A15, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
8.  sealed case class CaseClass16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], field12: Field[A12], field13: Field[A13], field14: Field[A14], field15: Field[A15], field16: Field[A16], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, extractField12: (Z) ⇒ A12, extractField13: (Z) ⇒ A13, extractField14: (Z) ⇒ A14, extractField15: (Z) ⇒ A15, extractField16: (Z) ⇒ A16, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
9.  sealed case class CaseClass17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], field12: Field[A12], field13: Field[A13], field14: Field[A14], field15: Field[A15], field16: Field[A16], field17: Field[A17], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, extractField12: (Z) ⇒ A12, extractField13: (Z) ⇒ A13, extractField14: (Z) ⇒ A14, extractField15: (Z) ⇒ A15, extractField16: (Z) ⇒ A16, extractField17: (Z) ⇒ A17, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
10.  sealed case class CaseClass18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], field12: Field[A12], field13: Field[A13], field14: Field[A14], field15: Field[A15], field16: Field[A16], field17: Field[A17], field18: Field[A18], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, extractField12: (Z) ⇒ A12, extractField13: (Z) ⇒ A13, extractField14: (Z) ⇒ A14, extractField15: (Z) ⇒ A15, extractField16: (Z) ⇒ A16, extractField17: (Z) ⇒ A17, extractField18: (Z) ⇒ A18, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
11.  sealed case class CaseClass19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], field12: Field[A12], field13: Field[A13], field14: Field[A14], field15: Field[A15], field16: Field[A16], field17: Field[A17], field18: Field[A18], field19: Field[A19], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, extractField12: (Z) ⇒ A12, extractField13: (Z) ⇒ A13, extractField14: (Z) ⇒ A14, extractField15: (Z) ⇒ A15, extractField16: (Z) ⇒ A16, extractField17: (Z) ⇒ A17, extractField18: (Z) ⇒ A18, extractField19: (Z) ⇒ A19, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
12.  sealed case class CaseClass2[A1, A2, Z](field1: Field[A1], field2: Field[A2], construct: (A1, A2) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
13.  sealed case class CaseClass20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], field12: Field[A12], field13: Field[A13], field14: Field[A14], field15: Field[A15], field16: Field[A16], field17: Field[A17], field18: Field[A18], field19: Field[A19], field20: Field[A20], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, extractField12: (Z) ⇒ A12, extractField13: (Z) ⇒ A13, extractField14: (Z) ⇒ A14, extractField15: (Z) ⇒ A15, extractField16: (Z) ⇒ A16, extractField17: (Z) ⇒ A17, extractField18: (Z) ⇒ A18, extractField19: (Z) ⇒ A19, extractField20: (Z) ⇒ A20, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
14.  sealed case class CaseClass21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], field12: Field[A12], field13: Field[A13], field14: Field[A14], field15: Field[A15], field16: Field[A16], field17: Field[A17], field18: Field[A18], field19: Field[A19], field20: Field[A20], field21: Field[A21], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, extractField12: (Z) ⇒ A12, extractField13: (Z) ⇒ A13, extractField14: (Z) ⇒ A14, extractField15: (Z) ⇒ A15, extractField16: (Z) ⇒ A16, extractField17: (Z) ⇒ A17, extractField18: (Z) ⇒ A18, extractField19: (Z) ⇒ A19, extractField20: (Z) ⇒ A20, extractField21: (Z) ⇒ A21, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
15.  sealed case class CaseClass22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], field10: Field[A10], field11: Field[A11], field12: Field[A12], field13: Field[A13], field14: Field[A14], field15: Field[A15], field16: Field[A16], field17: Field[A17], field18: Field[A18], field19: Field[A19], field20: Field[A20], field21: Field[A21], field22: Field[A22], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, extractField10: (Z) ⇒ A10, extractField11: (Z) ⇒ A11, extractField12: (Z) ⇒ A12, extractField13: (Z) ⇒ A13, extractField14: (Z) ⇒ A14, extractField15: (Z) ⇒ A15, extractField16: (Z) ⇒ A16, extractField17: (Z) ⇒ A17, extractField18: (Z) ⇒ A18, extractField19: (Z) ⇒ A19, extractField20: (Z) ⇒ A20, extractField21: (Z) ⇒ A21, extractField22: (Z) ⇒ A22, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
16.  sealed case class CaseClass3[A1, A2, A3, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], construct: (A1, A2, A3) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
17.  sealed case class CaseClass4[A1, A2, A3, A4, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], construct: (A1, A2, A3, A4) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
18.  sealed case class CaseClass5[A1, A2, A3, A4, A5, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], construct: (A1, A2, A3, A4, A5) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
19.  sealed case class CaseClass6[A1, A2, A3, A4, A5, A6, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], construct: (A1, A2, A3, A4, A5, A6) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
20.  sealed case class CaseClass7[A1, A2, A3, A4, A5, A6, A7, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], construct: (A1, A2, A3, A4, A5, A6, A7) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
21.  sealed case class CaseClass8[A1, A2, A3, A4, A5, A6, A7, A8, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], construct: (A1, A2, A3, A4, A5, A6, A7, A8) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
22.  sealed case class CaseClass9[A1, A2, A3, A4, A5, A6, A7, A8, A9, Z](field1: Field[A1], field2: Field[A2], field3: Field[A3], field4: Field[A4], field5: Field[A5], field6: Field[A6], field7: Field[A7], field8: Field[A8], field9: Field[A9], construct: (A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ Z, extractField1: (Z) ⇒ A1, extractField2: (Z) ⇒ A2, extractField3: (Z) ⇒ A3, extractField4: (Z) ⇒ A4, extractField5: (Z) ⇒ A5, extractField6: (Z) ⇒ A6, extractField7: (Z) ⇒ A7, extractField8: (Z) ⇒ A8, extractField9: (Z) ⇒ A9, annotations: Chunk[Any] = Chunk.empty) extends Record[Z] with Product with Serializable
23.  sealed case class GenericRecord(fieldSet: FieldSet, annotations: Chunk[Any] = Chunk.empty) extends Record[ListMap[String, _]] with Product with Serializable