h${Di      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                                                                                                                                     Safe-Inferred avroA  allows for compression/decompression of a block in an Avro container according to the Avro spec.avro1The name of the codec according to the Avro spec.avro Execute a  over a chunk of bytes possibly decompressing the chunk incrementally.*The API is somewhat more complex than say  to allow interleaving of decompression and binary decoding while still allowing proper error handling without resorting to async exceptions.avro"Compresses a lazy stream of bytes.avro0Block decompression function for blocks of Avro.avro specifies null required by Avro spec. (see  1https://avro.apache.org/docs/1.8.1/spec.html#null)avro specifies deflate$ codec required by Avro spec. (see  4https://avro.apache.org/docs/1.8.1/spec.html#deflate) Safe-Inferred   Safe-InferredA Safe-InferredmNone >2*avro1Get a 32-bit int (zigzag encoded, max of 5 bytes)+avro2Get a 64 bit int (zigzag encoded, max of 10 bytes),avroGet an zigzag encoded integral value consuming bytes till the msb is 0.2avroAvro encodes arrays and maps as a series of blocks. Each block starts with a count of the elements in the block. A series of blocks is always terminated with an empty block (encoded as a 0). )*+,-./0123 )*+,-./0123 Safe-Inferredt456456 Safe-Inferred<=>?<=>? None./?JKLMNJKLMN None #$%&8:>(Yavro=A named type in Avro has a name and, optionally, a namespace.A name is a string that starts with an ASCII letter or underscore followed by letters, underscores and digits:  name ::= [A-Za-z_][A-Za-z0-9_]* Examples include "_foo7", Bar_ and "x".A namespace is a sequence of names with the same lexical structure. When written as a string, the components of a namespace are separated with dots ( "com.example").Y represents a fullname@a name combined with a namespace. These are written and parsed as dot-separated strings. The Y TN Foo ["com", "example"] is rendered as "com.example.Foo".;Fullnames have to be globally unique inside an Avro schema.A namespace of [] or [""] is the "null namespace". In avro an explicitly null-namespaced identifier is written as ".Foo"}avro2N.B. It is possible to create a Haskell value (of } type) that is not a valid Avro schema by violating one of the above or one of the conditions called out in .avro&Dynamically enforced monomorphic type.avro%Dynamically enforced monomorphic typeavroSet of union options, schema for selected option, and the actual value.avroAn enum is a set of the possible symbols (the schema) and the selected symbolavro Build an  value from its components.avromkUnion subTypes Defines a union of the provided subTypes. N.B. it is invalid Avro to include another union or to have more than one of the same type as a direct member of the union. No check is done for this condition!avro,Render a fullname as a dot separated string. > renderFullname (TN Foo' ["com", "example"]) "com.example.Foo" > renderFullname (TN Foo []) ".Foo" avroParses a fullname into a Y/, assuming the string representation is valid. 2> parseFullname "com.example.Foo" TN { baseName = Foo$, components = ["com", "example"] } avroGet the name of the type. In the case of unions, get the name of the first value in the union schema.avroParse JSON-encoded avro data.avroParses a string literal into a bytestring in the format expected for bytes and fixed values. Will fail if every character does not have a codepoint between 0 and 255.avroTurn a  ByteString into a  that matches the format Avro expects from bytes and fixed literals in JSON. Each byte is mapped to a single Unicode codepoint between 0 and 255.avroPlaceholder NO-OP function!Validates a schema to ensure:All types are defined+Unions do not directly contain other unionsUnions are not ambiguous (may not contain more than one schema with the same type except for named types of record, fixed and enum)Default values for unions can be cast as the type indicated by the first structure.2Default values can be cast/de-serialize correctly.Named types are resolvableavrobuildTypeEnvironment schema builds a function mapping type names to the types declared in the traversed schema.This mapping includes both the base type names and any aliases they have. Aliases and normal names are not differentiated in any way.avroChecks that two schemas match. This is like equality of schemas, except  NamedTypes match against other types with the same name.This extends recursively: two records match if they have the same name, the same number of fields and the fields all match.avroextractBindings schema< traverses a schema and builds a map of all declared types.Types declared implicitly in record field definitions are also included. No distinction is made between aliases and normal names.avro5Merge two schemas to produce a third. Specifically, overlay schema reference fills in  NamedTypes in schema% using any matching definitions from  reference.avro:Extract the named inner type definition as its own schema.avroThis lets us write Y2s as string literals in a fully qualified style. "com.example.foo" is the name "foo" with the namespace  "com.example"; "foo" is the name "foo" with no namespace.avro Show the Y* as a string literal compatible with its  instance.avro*The name of the enum (includes namespace).avroAliases for the enum (if any).avro$Optional documentation for the enum.avroThe symbols of the enum.avroHow to handle unions. The way unions are formatted in JSON depends on whether we're parsing a normal Avro object or we're parsing a default declaration in a schema.'This function will only ever be passed  schemas. It should error out if this is not the case@it represents a bug in this code.avro1Callback to handle type names not in the schema.avro8The schema that we're generating a lookup function for.VXWYZ[\]^_`abcdefghijklmnopqtrsuvwxyz{|}~}~uvwxyz{|qtrsYZ[\mnopklhijdefg_`abc]^VXW None#$8:8avroDeconflicted record field.avro3How the value of this field should be treated. See  documentation.avroDepending on differences between reader and writer schemas, a record field can be found:Present in the reader schema but missing from the writer schema. In this case the reader field is marked as  with the default value from the reader schema. An index value represents the position of the field in the reader schema.Present in the writer schema but missing from the reader schema. In this case the record field is marked as : the corresponding bytes still need to be read from the payload (to advance the position in a bytestring), but the result is discarded.Present in both reader and writer schemas. In this case the field is marked to be read  with an index that represents the field's position in the reader schema.avroThis type represents a  deconflicted version of a Schema9. Schema resolution is described in Avro specification: https://avro.apache.org/docs/current/spec.html#Schema+ResolutionThis library represents "normal" schema and "deconflicted" schema as different types to avoid confusion between these two usecases (we shouldn't serialise values with such schema) and to be able to accomodate some extra information that links between how data is supposed transformed between what reader wants and what writer has.avroOrder of values represents order in the writer schema, an index represents order in a reader schemaavro%How to decode a value of target type Double. This type controls how many bits are needed to be read from the encoded bytestring. The number of bits can be different depending on differences between reader and writer schemas.The rules are described in https://avro.apache.org/docs/current/spec.html#Schema+ResolutionavroRead Int (32 bits) and cast it to Double4 (Rule: int is promotable to long, float, or double)avroRead Float (64 bits) and cast it to Double/ (Rule: float is promotable to float or double)avroRead Long (64 bits) and cast it to Double. (Rule: long is promotable to float or double)avro%How to decode a value of target type Float. This type controls how many bits are needed to be read from the encoded bytestring. The number of bits can be different depending on differences between reader and writer schemas.The rules are described in https://avro.apache.org/docs/current/spec.html#Schema+ResolutionavroRead Int (32 bits) and cast it to FloatavroRead Long (64 bits) and cast it to Float. (Rule: long is promotable to float or double)avroRead Float and use as isavro%How to decode a value of target type Long. This type controls how many bits are needed to be read from the encoded bytestring. The number of bits can be different depending on differences between reader and writer schemas.The rules are described in https://avro.apache.org/docs/current/spec.html#Schema+ResolutionavroRead Int (32 bits) and cast it to Long4 (Rule: int is promotable to long, float, or double)avroRead Long (64 bits) and use as isavroConverts Avro Schema to ReaderSchema trivially. This function is useful when no deconflicting is required.avroextractBindings schema< traverses a schema and builds a map of all declared types.Types declared implicitly in record field definitions are also included. No distinction is made between aliases and normal names.]^_`abcdefghijklmnopmnopklhijdefg_`abc]^ None:avrodeconflict writer reader will produce a schema that can decode with the writer's schema into the form specified by the reader's schema.;"None ;SNone  >;avro:Describes how to encode Haskell data types into Avro bytesNone  #$5C avroFeed more bytes. Pass the empty ByteString to signal end of input.avroLeftover bytesavroGenerates a new synchronization marker for encoding Avro containersavroReads the container as a list of blocks without decoding them into actual values.!This can be useful for streaming  splitting  merging Avro containers without paying the cost for Avro encoding/decoding. Each block is returned as a raw  annotated with the number of Avro values that are contained in this block.The "outer" error represents the error in opening the container itself (including problems like reading schemas embedded into the container.)avroFeeds a  to the  until exhausted. Consumes the  lazily.avroSplits container into a list of individual avro-encoded values. This version provides both encoded and decoded values.This is particularly useful when slicing up containers into one or more smaller files. By extracting the original bytestring it is possible to avoid re-encoding data.avroPacks a container from a given list of already encoded Avro values Each bytestring should represent exactly one one value serialised to Avro.avroPacks a container from a given list of already encoded Avro values Each bytestring should represent exactly one one value serialised to Avro.avroPacks a container from a given list of already encoded Avro values Each bytestring should represent exactly one one value serialised to Avro.avroPacks a new container from a list of already encoded Avro blocks. Each block is denoted as a pair of a number of objects within that block and the block content.avroPacks a new container from a list of already encoded Avro blocks. Each block is denoted as a pair of a number of objects within that block and the block content.avro4Creates an Avro container header for a given schema.avro Error messageavroLeftover bytesNone8:>Favro.Descrives how to convert a given intermediate  into a Haskell data type.avroAn intermediate data structute for decoding between Avro bytes and Haskell types.Because reader and writer schemas, and therefore expected data types and layout can be different, deserialising bytes into Haskell types directly is not possible.To overcome this issue this intermediate data structure is used: bytes are decoded into values of type  (using reader's layout and rules) and then translated to target Haskell types using  type class machinery.None %HavroExtracts all the records from the schema (flattens the schema) Named types get resolved when needed to include at least one "inlined" schema in each record and to make each record self-contained. Note: Namespaces are not really supported in this version. All the namespaces (including inlined into full names) will be ignored during names resolution.None2;HNone->TO avro Converts } into . This function may be useful when it is known that the writer and the reader schemas are the same.avroSerialises an individual value into Avro with the schema provided.avroSerialises an individual value into Avro using the schema from its coresponding  instance.avro+Deserialises an individual value from Avro.avroDeserialises an individual value from Avro using the schema from its coresponding .NOTE: This function is only to be used when reader and writes schemas are known to be the same. Because only one schema is known at this point, and it is the reader schema, no decondlicting can be performed.avro*Decodes the container using a schema from  as a reader schema.Errors are reported as a part of the list and the list will stop at first error. This means that the consumer will get all the "good" content from the container until the error is detected, then this error and then the list is finished.avroDecodes the container as a list of values of the requested type.Errors are reported as a part of the list and the list will stop at first error. This means that the consumer will get all the "good" content from the container until the error is detected, then this error and then the list is finished.avroDecodes the container as a list of values of the requested type.The provided reader schema will be de-conflicted with the schema embedded with the container.Errors are reported as a part of the list and the list will stop at first error. This means that the consumer will get all the "good" content from the container until the error is detected, then this error and then the list is finished.avro?Splits container into a list of individual avro-encoded values.This is particularly useful when slicing up containers into one or more smaller files. By extracting the original bytestring it is possible to avoid re-encoding data.avroSplits container into a list of individual avro-encoded values. This version provides both encoded and decoded values.This is particularly useful when slicing up containers into one or more smaller files. By extracting the original bytestring it is possible to avoid re-encoding data.avroEncode chunks of values into a container, using 16 random bytes for the synchronization markers and a corresponding  schema. Blocks are compressed (or not) according to the given  ( or ).avroEncode chunks of values into a container, using 16 random bytes for the synchronization markers. Blocks are compressed (or not) according to the given  ( or ).avroEncode chunks of objects into a container, using the provided ByteString as the synchronization markers.YZ[\]^_`abcdefghijklmnopqtrsuvwxyz{|}~}~uvwxyz{|qtrsYZ[\mnopklhijdefg_`abc]^None5678U==None  #$28i4avroDerives Avro from a given schema file. Generates data types, FromAvro and ToAvro instances.avroHow to build field names for generated data types. The first argument is the type name to use as a prefix, rendered according to the  setting.avro7Determines field representation of generated data typesavroControls how we handle namespaces when defining Haskell type and field names.avroDescribes the representation of a field for a derived data type. The field will be derived as if it were written with an {- UNPACK -} pragma.avroDescribes the strictness of a field for a derived data type. The field will be derived as if it were written with a !.avro?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_` a a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~     a a                                                                                                                                                     e g f                                                                                                                                            n#avro-0.6.0.0-DoOm2DJah3nIktWo4nyiQeData.Avro.DerivingData.Avro.CodecData.Avro.Internal.TimeData.Avro.Internal.ZagData.Avro.Internal.DecodeRawData.Avro.Internal.GetData.Avro.Internal.ZigData.Avro.Internal.EncodeRawData.Avro.Schema.DecimalData.Avro.Schema.SchemaData.Avro.Schema.ReadSchemaData.Avro.Schema.DeconflictData.Avro.HasAvroSchemaData.Avro.JSONData.Avro.Encoding.ToAvroData.Avro.Internal.ContainerData.Avro.Encoding.FromAvroData.Avro.Deriving.NormSchemaData.Avro.Deriving.Lift Data.AvroData.Avro.EitherN)raw-strings-qq-1.1-CnHDj5KA9CM15ZkVQP2bmFText.RawString.QQrCodec codecNamecodecDecompress codecCompress Decompress nullCodec deflateCodecepoch epochDatedaysSinceEpochfromDaysSinceEpochdiffTimeToMicrosmicrosToDiffTimediffTimeToMillismillisToDiffTimeutcTimeToMicrosutcTimeToMillismicrosToUTCTimemillisToUTCTimeZagZaggedzag $fZagWord $fZagWord64 $fZagWord32 $fZagWord16 $fZagWord8 DecodeRaw decodeRaw$fDecodeRawInt64$fDecodeRawInt32$fDecodeRawInt16$fDecodeRawInt8$fDecodeRawInt$fDecodeRawWord64$fDecodeRawWord32$fDecodeRawWord16$fDecodeRawWord8$fDecodeRawWord getBooleangetIntgetLong getZigZaggetBytes getBytesLazy getStringgetFloat getDouble decodeBlocks sFromIntegralZigZiggedzig$fZigInt $fZigInt64 $fZigInt32 $fZigInt16 $fZigInt8 EncodeRaw encodeRawputIlong0$fEncodeRawInt64$fEncodeRawInt32$fEncodeRawInt16$fEncodeRawInt8$fEncodeRawInt$fEncodeRawWord64$fEncodeRawWord32$fEncodeRawWord16$fEncodeRawWord8$fEncodeRawWordDecimal unDecimalfromUnderlyingValueunderlyingValue $fEqDecimal $fOrdDecimal $fShowDecimal $fReadDecimal $fNumDecimal$fFractionalDecimal $fRealDecimalResultSuccessErrorTypeNameTNbaseName namespaceLogicalTypeStringUUIDLogicalTypeLongDecimalL TimeMicrosTimestampMillisTimestampMicrosLogicalTypeIntDecimalIDate TimeMillisLogicalTypeFixedDecimalFDurationLogicalTypeBytesDecimalB precisionscaleOrder Ascending DescendingIgnoreFieldfldName fldAliasesfldDocfldOrderfldType fldDefaultSchemaNullBooleanIntLongFloatDoubleBytesStringArrayMap NamedTypeRecordEnumUnionFixed logicalTypeI logicalTypeL logicalTypeB logicalTypeSitemvaluesnamealiasesdocfieldssymbolsoptionssize logicalTypeF DefaultValueDNullDBooleanDIntDLongDFloatDDoubleDBytesDStringDArrayDMapDRecordDUnionDFixedDEnumString'Bytes'Long'Int'mkEnummkUnionrenderFullname parseFullnametypeNamebadValueresultToEither parseAvroJSON parseBytesserializeBytesvalidateSchemabuildTypeEnvironmentmatchesextractBindingsexpandNamedTypesoverlay subdefinition$fFromJSONOrder $fToJSONOrder$fHashableTypeName$fIsStringTypeName$fShowTypeName$fToJSONDefaultValue$fToJSONSchema$fFromJSONSchema $fEqSchema$fTraversableResult$fFoldableResult$fMonoidResult$fSemigroupResult$fMonadPlusResult$fAlternativeResult$fApplicativeResult$fMonadError[]Result$fMonadFailResult$fFunctorResult $fMonadResult $fEqResult $fOrdResult $fShowResult$fGenericResult$fNFDataResult $fOrdSchema $fShowSchema$fGenericSchema$fNFDataSchema $fEqField $fOrdField $fShowField$fGenericField $fNFDataField$fEqDefaultValue$fOrdDefaultValue$fShowDefaultValue$fGenericDefaultValue$fNFDataDefaultValue $fEqTypeName $fOrdTypeName$fGenericTypeName$fNFDataTypeName$fEqLogicalTypeString$fShowLogicalTypeString$fOrdLogicalTypeString$fGenericLogicalTypeString$fNFDataLogicalTypeString$fEqLogicalTypeLong$fShowLogicalTypeLong$fOrdLogicalTypeLong$fGenericLogicalTypeLong$fNFDataLogicalTypeLong$fEqLogicalTypeInt$fShowLogicalTypeInt$fOrdLogicalTypeInt$fGenericLogicalTypeInt$fNFDataLogicalTypeInt$fEqLogicalTypeFixed$fShowLogicalTypeFixed$fOrdLogicalTypeFixed$fGenericLogicalTypeFixed$fNFDataLogicalTypeFixed$fEqLogicalTypeBytes$fShowLogicalTypeBytes$fOrdLogicalTypeBytes$fGenericLogicalTypeBytes$fNFDataLogicalTypeBytes$fGenericDecimal$fNFDataDecimal $fEqOrder $fOrdOrder $fShowOrder$fGenericOrder $fNFDataOrder ReadField fldStatus FieldStatusAsIsIgnored Defaulted ReadSchema FreeUnion longReadFrom floatReadFromdoubleReadFromposty ReadDouble DoubleFromIntDoubleFromFloatDoubleFromLong ReadFloat FloatFromInt FloatFromLongReadLong LongFromInt fromSchema fromField $fEqReadField$fShowReadField$fGenericReadField$fNFDataReadField$fEqReadSchema$fShowReadSchema$fGenericReadSchema$fNFDataReadSchema$fShowFieldStatus$fEqFieldStatus$fOrdFieldStatus$fGenericFieldStatus$fNFDataFieldStatus$fShowReadDouble$fEqReadDouble$fOrdReadDouble$fGenericReadDouble$fNFDataReadDouble$fShowReadFloat $fEqReadFloat$fOrdReadFloat$fGenericReadFloat$fNFDataReadFloat$fShowReadLong $fEqReadLong $fOrdReadLong$fGenericReadLong$fNFDataReadLong deconflict HasAvroSchemaschemaschemaOfwrapTag$fHasAvroSchemaSet$fHasAvroSchemaVector$fHasAvroSchemaVector0$fHasAvroSchemaArray$fHasAvroSchema[]$fHasAvroSchemaMaybe$fHasAvroSchemaHashMap$fHasAvroSchemaMap$fHasAvroSchemaHashMap0$fHasAvroSchemaMap0$fHasAvroSchemaHashMap1$fHasAvroSchemaMap1$fHasAvroSchemaEither$fHasAvroSchemaIdentity$fHasAvroSchemaUTCTime$fHasAvroSchemaDiffTime$fHasAvroSchemaDay$fHasAvroSchemaUUID$fHasAvroSchemaDecimal$fHasAvroSchemaByteString$fHasAvroSchemaByteString0$fHasAvroSchemaText$fHasAvroSchemaText0$fHasAvroSchemaFloat$fHasAvroSchemaDouble$fHasAvroSchemaInt64$fHasAvroSchemaInt32$fHasAvroSchemaInt16$fHasAvroSchemaInt8$fHasAvroSchemaInt$fHasAvroSchema()$fHasAvroSchemaBool$fHasAvroSchemaWord64$fHasAvroSchemaWord32$fHasAvroSchemaWord16$fHasAvroSchemaWord8decodeAvroJSONToAvrotoAvroEncoder runEncoder.=record$fToAvroEither$fToAvroIdentity $fToAvroMaybe$fToAvroHashMap $fToAvroMap$fToAvroVector $fToAvroArray$fToAvroVector0 $fToAvro[] $fToAvroText $fToAvroText0$fToAvroByteString$fToAvroByteString0$fToAvroUTCTime$fToAvroDiffTime $fToAvroDay $fToAvroUUID$fToAvroDecimal $fToAvroBool $fToAvro() $fToAvroFloat$fToAvroDouble$fToAvroWord64$fToAvroWord32$fToAvroWord16 $fToAvroWord8 $fToAvroInt64 $fToAvroInt32 $fToAvroIntBlocksBlockMoreDoneContainerHeader syncBytes decompresscontainedSchema nrSyncBytes newSyncBytesgetContainerHeaderdecodeRawBlocks foldrBlocksdecodeRawBlocksIncrementalextractContainerValuesBytesextractContainerValues!extractContainerValuesIncrementalpackContainerValuespackContainerValuesWithSyncpackContainerValuesWithSync'packContainerBlockspackContainerBlocksWithSynccontainerHeaderWithSyncconsumeN parseCodectakeWhileInclusive$fFunctorBlocksFromAvrofromAvroValuegetValue$fFromAvroHashMap $fFromAvroMap$fFromAvroEither$fFromAvroMaybe$fFromAvroIdentity$fFromAvroVector$fFromAvroVector0 $fFromAvro[]$fFromAvroUTCTime$fFromAvroDiffTime $fFromAvroDay$fFromAvroUUID$fFromAvroDecimal$fFromAvroByteString$fFromAvroByteString0$fFromAvroText$fFromAvroBool $fFromAvro()$fFromAvroFloat$fFromAvroDouble$fFromAvroInt64$fFromAvroInt32 $fFromAvroInt $fEqValue $fShowValue$fGenericValue $fNFDataValueextractDerivablesgetTypes normSchema$fLiftLiftedRepHashMap$fLiftLiftedRepVector$fLiftLiftedRepText$fLiftLiftedRepByteString$fLiftLiftedRepSchema $fLiftLiftedRepLogicalTypeString$fLiftLiftedRepLogicalTypeLong$fLiftLiftedRepLogicalTypeInt$fLiftLiftedRepLogicalTypeFixed$fLiftLiftedRepLogicalTypeBytes$fLiftLiftedRepDecimal$fLiftLiftedRepTypeName$fLiftLiftedRepOrder$fLiftLiftedRepField$fLiftLiftedRepDefaultValuereadSchemaFromSchemaencodeValueWithSchema encodeValuedecodeValueWithSchema decodeValuedecodeContainer!decodeContainerWithEmbeddedSchemadecodeContainerWithReaderSchemadecodeContainerValuesBytesencodeContainerencodeContainerWithSchemaencodeContainerWithSyncEither10E10_1E10_2E10_3E10_4E10_5E10_6E10_7E10_8E10_9E10_10Either9E9_1E9_2E9_3E9_4E9_5E9_6E9_7E9_8E9_9Either8E8_1E8_2E8_3E8_4E8_5E8_6E8_7E8_8Either7E7_1E7_2E7_3E7_4E7_5E7_6E7_7Either6E6_1E6_2E6_3E6_4E6_5E6_6Either5E5_1E5_2E5_3E5_4E5_5Either4E4_1E4_2E4_3E4_4Either3E3_1E3_2E3_3putIndexedValue$fToAvroEither3$fFromAvroEither3$fHasAvroSchemaEither3$fBitraversableEither3$fBifoldableEither3$fMonadEither3$fBifunctorEither3$fApplicativeEither3$fToAvroEither4$fFromAvroEither4$fHasAvroSchemaEither4$fBitraversableEither4$fBifoldableEither4$fMonadEither4$fBifunctorEither4$fApplicativeEither4$fToAvroEither5$fFromAvroEither5$fHasAvroSchemaEither5$fBitraversableEither5$fBifoldableEither5$fMonadEither5$fBifunctorEither5$fApplicativeEither5$fToAvroEither6$fFromAvroEither6$fHasAvroSchemaEither6$fBitraversableEither6$fBifoldableEither6$fMonadEither6$fBifunctorEither6$fApplicativeEither6$fToAvroEither7$fFromAvroEither7$fHasAvroSchemaEither7$fBitraversableEither7$fBifoldableEither7$fMonadEither7$fBifunctorEither7$fApplicativeEither7$fToAvroEither8$fFromAvroEither8$fHasAvroSchemaEither8$fBitraversableEither8$fBifoldableEither8$fMonadEither8$fBifunctorEither8$fApplicativeEither8$fToAvroEither9$fFromAvroEither9$fHasAvroSchemaEither9$fBitraversableEither9$fBifoldableEither9$fMonadEither9$fBifunctorEither9$fApplicativeEither9$fToAvroEither10$fFromAvroEither10$fHasAvroSchemaEither10$fBitraversableEither10$fBifoldableEither10$fMonadEither10$fBifunctorEither10$fApplicativeEither10 $fEqEither10 $fOrdEither10$fShowEither10$fGenericEither10$fFunctorEither10$fFoldableEither10$fTraversableEither10 $fEqEither9 $fOrdEither9 $fShowEither9$fGenericEither9$fFunctorEither9$fFoldableEither9$fTraversableEither9 $fEqEither8 $fOrdEither8 $fShowEither8$fGenericEither8$fFunctorEither8$fFoldableEither8$fTraversableEither8 $fEqEither7 $fOrdEither7 $fShowEither7$fGenericEither7$fFunctorEither7$fFoldableEither7$fTraversableEither7 $fEqEither6 $fOrdEither6 $fShowEither6$fGenericEither6$fFunctorEither6$fFoldableEither6$fTraversableEither6 $fEqEither5 $fOrdEither5 $fShowEither5$fGenericEither5$fFunctorEither5$fFoldableEither5$fTraversableEither5 $fEqEither4 $fOrdEither4 $fShowEither4$fGenericEither4$fFunctorEither4$fFoldableEither4$fTraversableEither4 $fEqEither3 $fOrdEither3 $fShowEither3$fGenericEither3$fFunctorEither3$fFoldableEither3$fTraversableEither3 DeriveOptionsfieldNameBuilderfieldRepresentationnamespaceBehaviorFieldUnpackedness UnpackedFieldNonUnpackedFieldFieldStrictness StrictField LazyFieldNamespaceBehaviorIgnoreNamespacesHandleNamespacesCustomdefaultDeriveOptionsmkPrefixedFieldName mkLazyFieldmkStrictPrimitiveFieldmkAsIsFieldNamederiveAvroWithOptionsderiveAvroWithOptions' deriveAvro deriveAvro'deriveAvroFromByteString makeSchemamakeSchemaFromByteStringmakeSchemaFrom$fGenericDeriveOptions$fGenericFieldUnpackedness$fGenericFieldStrictnessbinary-0.8.8.0Data.Binary.Get.InternalGet text-1.2.3.2Data.Text.InternalTextbase Data.StringIsStringbytestring-0.10.10.0Data.ByteString.Internal ByteStringData.ByteString.Lazy.InternalGHC.IntInt32Int64ghc-prim GHC.Typesghc-boot-th-8.10.2GHC.LanguageExtensions.TypeDuplicateRecordFields