h*D<      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN 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 { | } ~                                                                                                                                                                                                                                                                                          0.6.2.0 Safe-Inferred"WavroInternal type to help construct a lazy list of decompressed bytes interleaved with errors if any.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-Inferred Safe-Inferred!"!" Safe-Inferred".avro1Get a 32-bit int (zigzag encoded, max of 5 bytes)/avro2Get a 64 bit int (zigzag encoded, max of 10 bytes)0avroGet an zigzag encoded integral value consuming bytes till the msb is 0.6avroAvro 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). -./01234567 -./01234567 Safe-Inferred89:89: Safe-InferredF@ABC@ABC  Safe-Inferred01NOPNOP  Safe-Inferred"%&'(<>?-[avro=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").[ represents a fullname@a name combined with a namespace. These are written and parsed as dot-separated strings. The [ 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"_avroThe decimal logical type represents arbitrary-precision decimal numbers. Numbers are represented as unscaled * (10 ** -scale) where scale! is part of the logical type and unscaled= is an integer represented by the underlying primitive type.Instances of the decimal logical type need to specify a scale and  precision.decimal= can be encoded as one of several different primitive types: bytes fixed long intFor long and int, unscaled is the underlying number.For bytes and fixed, unscaled is represented as a two's-complement signed integer in big-endian byte order.Note: int and long representations for decimal are not part of the  6https://avro.apache.org/docs/current/spec.html#Decimalcurrent Avro specification, but they are supported by some language implementations including the official Java library. Implementations that do not support this should ignore the logical type and use the underlying primitive type instead.aavro>The maximum number of digits that can be represented by this decimal type.  precision > 0bavroThe scale in unscaled * (10 ** -scale) for this type. 0 D scale D precisiondavro'A Universally Unique Identifier (UUID)./Encoded as a string that is valid according to  $https://www.ietf.org/rfc/rfc4122.txt RFC 4122.favro2An arbitrary-precision signed decimal number. See _.gavro)A time of day with microsecond precision.5Encoded as the number of microseconds after midnight.havro+A UTC timestamp with millisecond precision.Encoded as the number of milliseconds before/after the Unix epoch (1970-01-01 00:00:00.000).iavro+A UTC timestamp with microsecond precision.Encoded as the number of microseconds before/after the Unix epoch (1970-01-01 00:00:00.000000).javroA timestamp in the local timezone, whatever that happens to be, with millisecond precision.Encoded as the number of milliseconds before/after the Unix epoch (1970-01-01 00:00:00.000).kavroA timestamp in the local timezone, whatever that happens to be, with microsecond precision.Encoded as the number of microseconds before/after the Unix epoch (1970-01-01 00:00:00.000000).mavro2An arbitrary-precision signed decimal number. See _.navro A date (eg  2020-01-10) with no timezone/locale.Encoded as the number of days before/after the Unix epoch (1970-01-01).oavro)A time of day with millisecond precision.5Encoded as the number of milliseconds after midnight.qavro2An arbitrary-precision signed decimal number. See _.ravroAn interval of time, represented as some number of months, days and milliseconds.Encoded as three little-endian unsigned integers for months, days and milliseconds respectively.tavro2An arbitrary-precision signed decimal number. See _.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 [/, assuming the string representation is valid. 2> parseFullname "com.example.Foo" TN { baseName = Foo$, components = ["com", "example"] } avroBuild a type name out of the name and  namespace5 fields of an Avro record, enum or fixed definition.:This follows the rules laid out in the Avro specification: If the "name"* field contains dots, it is parsed as a fullname (see  ) and the  "namespace" field is ignored if present.Otherwise, if both "name" and  "namespace"( fields are present, they make up the fullname If only the "name" field is specified, the  "namespace" is inferred from the namespace of the most tightly enclosing schema or protocol (the "context"). If there is no containing schema, the namespace is null.avroGet the name of the type. In the case of unions, get the name of the first value in the union schema.avroGet the aliases of the type.avroA helper function that parses an Avro schema from JSON, resolving namespaces based on context.See , for details on how namespaces are resolved.avroParse aliases, inferring the namespace based on the type being aliases.avroA helper function that parses field definitions, using the name of the record for namespace resolution (see  for more details).avro Serializes a  to JSON.The optional name is used as the context for namespace inference. If the context has the namespace  com.example, then any names in the  com.example; namespace will be rendered without an explicit namespace.avroField defaults are in the normal Avro JSON format except for unions. Default values for unions are specified as JSON encodings of the first type in the union.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 [2s 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 [* 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.avroThe name of the enclosing schema or protocol, if any. This provides the context for inferring namespaces.avroThe "name" field of the definition.avroThe  "namespace"& field of the definition, if present.avroThe resulting fullname? of the generated type, according to the rules laid out above.avroThe name of the enclosing type of this schema, if any. Used to resolve namespaces.avroAn Avro schema encoded in JSON.avro#The name of the type being aliased.avro The aliases.avro-The name of the record this field belongs to.avro1The JSON object defining the field in the schema.avro;The context used for keeping track of namespace inference.avro The schema to serialize to JSON.avro,Lookup function for names defined in schema.avro-The schema of the default value being parsed.avroJSON encoding of an Avro value.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.yz{|}~uxvw[\]^_`bastpqrlmnoefghijkcdXYZyz{|}~uxvw[\]^_`bastpqrlmnoefghijkcdXYZ  Safe-Inferred%&<>O avroDeconflicted 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._`bastpqrlmnoefghijkcd_`bastpqrlmnoefghijkcd  Safe-InferredQavrodeconflict writer reader will produce a schema that can decode with the writer's schema into the form specified by the reader's schema.^avro.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.avroDescrive the value in a way that is safe to use in error messages (i.e. do not print values)avro"Read a Map from blocks of KV pairsavroRead an array from blocks.avro;This function will be unnecessary when we fully migrate to  Safe-Inferred"'`yavroExtracts 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. Safe-Inferred6?` Safe-Inferred/l- 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{|}~uxvw[\]^_`bastpqrlmnoefghijkcdyz{|}~uxvw[\]^_`bastpqrlmnoefghijkcd Safe-Inferred9:;<m== Safe-Inferred "%&6<avroDerives 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[\]^_`abcde f g h i j k l m n o p q r s t u v f f w x y z { | } ~                                                                                                                                                           i k j                                                                                                                                                  r      #avro-0.6.2.0-Dh8fABvpyMh8Vdr29AWZjSData.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.EitherNavro)raw-strings-qq-1.1-AMHklYQwXNQ4E8os8iqLbpText.RawString.QQrCodec codecNamecodecDecompress codecCompress Decompress nullCodec deflateCodecepoch epochDatedaysSinceEpochfromDaysSinceEpochdiffTimeToMicrosmicrosToDiffTimediffTimeToMillismillisToDiffTimeutcTimeToMicrosutcTimeToMillismicrosToUTCTimemillisToUTCTimelocalTimeToMicroslocalTimeToMillismicrosToLocalTimemillisToLocalTimeZagZaggedzag $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$fEncodeRawWordDecimalfromUnderlyingValueunderlyingValue $fEqDecimal $fOrdDecimal $fShowDecimal $fReadDecimal $fNumDecimal$fFractionalDecimal $fRealDecimalResultSuccessErrorTypeNameTNbaseName namespace precisionscaleLogicalTypeStringUUIDLogicalTypeLongDecimalL TimeMicrosTimestampMillisTimestampMicrosLocalTimestampMillisLocalTimestampMicrosLogicalTypeIntDecimalIDate TimeMillisLogicalTypeFixedDecimalFDurationLogicalTypeBytesDecimalBOrder Ascending DescendingIgnoreFieldfldName fldAliasesfldDocfldOrderfldType fldDefaultSchemaNullBooleanIntLongFloatDoubleBytesStringArrayMap NamedTypeRecordEnumUnionFixed logicalTypeI logicalTypeL logicalTypeB logicalTypeSitemvaluesnamealiasesdocfieldssymbolsoptionssize logicalTypeF DefaultValueDNullDBooleanDIntDLongDFloatDDoubleDBytesDStringDArrayDMapDRecordDUnionDFixedDEnumString'Bytes'Long'Int'mkEnummkUnionrenderFullname parseFullnametypeName typeAliasesbadValueresultToEither parseAvroJSON parseBytesserializeBytesvalidateSchemabuildTypeEnvironmentmatchesextractBindingsexpandNamedTypesoverlay subdefinition$fFromJSONOrder $fToJSONOrder$fHashableTypeName$fIsStringTypeName$fShowTypeName$fToJSONDefaultValue$fToJSONSchema$fFromJSONSchema $fEqSchema$fTraversableResult$fFoldableResult$fMonoidResult$fSemigroupResult$fMonadPlusResult$fAlternativeResult$fApplicativeResult$fMonadErrorListResult$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$fEqLogicalTypeBytes$fShowLogicalTypeBytes$fOrdLogicalTypeBytes$fGenericLogicalTypeBytes$fNFDataLogicalTypeBytes$fEqLogicalTypeFixed$fShowLogicalTypeFixed$fOrdLogicalTypeFixed$fGenericLogicalTypeFixed$fNFDataLogicalTypeFixed$fEqLogicalTypeInt$fShowLogicalTypeInt$fOrdLogicalTypeInt$fGenericLogicalTypeInt$fNFDataLogicalTypeInt$fEqLogicalTypeLong$fShowLogicalTypeLong$fOrdLogicalTypeLong$fGenericLogicalTypeLong$fNFDataLogicalTypeLong$fGenericDecimal$fNFDataDecimal$fEqLogicalTypeString$fShowLogicalTypeString$fOrdLogicalTypeString$fGenericLogicalTypeString$fNFDataLogicalTypeString $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$fHasAvroSchemaList$fHasAvroSchemaMaybe$fHasAvroSchemaHashMap$fHasAvroSchemaMap$fHasAvroSchemaHashMap0$fHasAvroSchemaMap0$fHasAvroSchemaHashMap1$fHasAvroSchemaMap1$fHasAvroSchemaEither$fHasAvroSchemaIdentity$fHasAvroSchemaLocalTime$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 $fToAvroList $fToAvroText $fToAvroText0$fToAvroByteString$fToAvroByteString0$fToAvroLocalTime$fToAvroUTCTime$fToAvroDiffTime $fToAvroDay $fToAvroUUID$fToAvroDecimal $fToAvroBool $fToAvro() $fToAvroFloat$fToAvroDouble$fToAvroWord64$fToAvroWord32$fToAvroWord16 $fToAvroWord8 $fToAvroInt64 $fToAvroInt32 $fToAvroIntBlocksBlockMoreDoneContainerHeader syncBytes decompresscontainedSchema nrSyncBytes newSyncBytesgetContainerHeaderdecodeRawBlocks foldrBlocksdecodeRawBlocksIncrementalextractContainerValuesBytesextractContainerValues!extractContainerValuesIncrementalpackContainerValuespackContainerValuesWithSyncpackContainerValuesWithSync'packContainerBlockspackContainerBlocksWithSynccontainerHeaderWithSyncconsumeN parseCodectakeWhileInclusive$fFunctorBlocksFromAvrofromAvroValue describeValuegetValue$fFromAvroHashMap $fFromAvroMap$fFromAvroEither$fFromAvroMaybe$fFromAvroIdentity$fFromAvroVector$fFromAvroVector0$fFromAvroList$fFromAvroLocalTime$fFromAvroUTCTime$fFromAvroDiffTime $fFromAvroDay$fFromAvroUUID$fFromAvroDecimal$fFromAvroByteString$fFromAvroByteString0$fFromAvroText$fFromAvroBool $fFromAvro()$fFromAvroFloat$fFromAvroDouble$fFromAvroInt64$fFromAvroInt32 $fFromAvroInt $fEqValue $fShowValue$fGenericValue $fNFDataValueextractDerivablesgetTypes normSchema$fLiftBoxedRepSchema$fLiftBoxedRepLogicalTypeString$fLiftBoxedRepLogicalTypeLong$fLiftBoxedRepLogicalTypeInt$fLiftBoxedRepLogicalTypeFixed$fLiftBoxedRepLogicalTypeBytes$fLiftBoxedRepDecimal$fLiftBoxedRepTypeName$fLiftBoxedRepOrder$fLiftBoxedRepField$fLiftBoxedRepDefaultValuereadSchemaFromSchemaencodeValueWithSchema 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$fGenericFieldStrictnessChunkbinary-0.8.9.1Data.Binary.Get.InternalGet mkTypeNameparseSchemaJSON mkAliases parseField schemaToJSONparseFieldDefault text-2.0.2Data.Text.InternalTextbase Data.StringIsStringbytestring-0.11.5.2Data.ByteString.Internal.Type ByteStringData.ByteString.Lazy.Internal getKVBlocks getBlocksOf convertValueGHC.IntInt32Int64ghc-prim GHC.Typesghc-boot-th-9.6.3GHC.LanguageExtensions.TypeDuplicateRecordFieldssetName renderNamenewNames