!&,      !"#$%&'()*+,-./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 { | } ~                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 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 { | } ~                            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~SafeSX3avrobInternal type to help construct a lazy list of decompressed bytes interleaved with errors if any.avroA b 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 G 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)Safe4s  SafeHV5)Safe5wNone=?SX`< *avro1Get a 32-bit int (zigzag encoded, max of 5 bytes)+avro2Get a 64 bit int (zigzag encoded, max of 10 bytes),avroGGet 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 )*+,-./0123SafeHV<456456SafeX=<=>?<=>? None-.>HMX=JKLMNJKLMN None"#$%45679=?@APX_gmYavro=A named type in Avro has a name and, optionally, a namespace.oA 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 }n 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 typeavroGSet of union options, schema for selected option, and the actual value.avroMAn 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"] } 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.avrogGet the name of the type. In the case of unions, get the name of the first value in the union schema.avro_A helper function that parses an Avro schema from JSON, resolving namespaces based on context.See , for details on how namespaces are resolved.avroGParse aliases, inferring the namespace based on the type being aliases.avromA helper function that parses field definitions, using the name of the record for namespace resolution (see  for more details).avro Serializes a } to JSON.dThe 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)UDefault 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 schemaU 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.avroIChecks 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.avrokThe 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.avroSThe 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 shouldE 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.jVXWYZ[\]^_`abcdefghijklmnopqtrsuvwxyz{|}~n}~uvwxyz{|qtrsYZ[\mnopklhijdefg_`abc]^VXW None"#79_avroDeconflicted record field.avro3How the value of this field should be treated. See  documentation.avroYDepending on differences between reader and writer schemas, a record field can be found:mPresent 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.mPresent 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.XPresent in both reader and writer schemas. In this case the field is marked to be read J 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+ResolutionMThis 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.;avrocOrder of values represents order in the writer schema, an index represents order in a reader schema@avro%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+ResolutionAavroRead Int (32 bits) and cast it to Double4 (Rule: int is promotable to long, float, or double)BavroRead Float (64 bits) and cast it to Double/ (Rule: float is promotable to float or double)CavroRead Long (64 bits) and cast it to Double. (Rule: long is promotable to float or double)Eavro%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+ResolutionFavroRead Int (32 bits) and cast it to FloatGavroRead Long (64 bits) and cast it to Float. (Rule: long is promotable to float or double)HavroRead Float and use as isIavro%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+ResolutionJavroRead Int (32 bits) and cast it to Long4 (Rule: int is promotable to long, float, or double)KavroRead Long (64 bits) and use as isLavrokConverts Avro Schema to ReaderSchema trivially. This function is useful when no deconflicting is required.NavroextractBindings 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.U]^_`abcdefghijklmnop! (#$%*)"&'+<>5,.12346789:;=?-/0@DABCEHFGIKJLMNU! (#$%*)"&'+<>5,.12346789:;=?-/0IKJEHFG@DABCLMNmnopklhijdefg_`abc]^ NonePkavrodeconflict writer readerp will produce a schema that can decode with the writer's schema into the form specified by the reader's schema.<Schema resolution rules are described by the specification: @https://avro.apache.org/docs/current/spec.html#Schema+Resolutionkk None,=?XkAlmnolmnoNoneXNone =?EHSVXkOavro:Describes how to encode Haskell data types into Avro bytesNone "#PSXkm3 avroCGenerates a new synchronization marker for encoding Avro containersavroQReads the container as a list of blocks without decoding them into actual values.!This can be useful for streaming  splitting M merging Avro containers without paying the cost for Avro encoding/decoding. Each block is returned as a raw L 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.)avrowSplits 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.None79=?P_mzavro.Descrives how to convert a given intermediate  into a Haskell data type.avroQAn 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.hTo overcome this issue this intermediate data structure is used: bytes are decoded into values of type V (using reader's layout and rules) and then translated to target Haskell types using  type class machinery.avro]Descrive the value in a way that is safe to use in error messages (i.e. do not print values)avro;This function will be unnecessary when we fully migrate to None$avrocExtracts 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.None1:pNone,=?X`gkE.  avro Converts } into d. This function may be useful when it is known that the writer and the reader schemas are the same. avroBSerialises an individual value into Avro with the schema provided. avroQSerialises an individual value into Avro using the schema from its coresponding l instance.avro+Deserialises an individual value from Avro.avroRDeserialises an individual value from Avro using the schema from its coresponding l.NOTE: YThis function is only to be used when reader and writes schemas are known to be the same.P 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 l 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.avro@Decodes 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.avro@Decodes 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.avrowSplits 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.avrouEncode chunks of values into a container, using 16 random bytes for the synchronization markers and a corresponding l@ 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 ).avroiEncode chunks of objects into a container, using the provided ByteString as the synchronization markers._YZ[\]^_`abcdefghijklmnopqtrsuvwxyz{|}~klmn   c}~uvwxyz{|qtrsYZ[\mnopklhijdefg_`abc]^k   lmnNone4567XkH="! #,+*)('&%$-543210/.6=<;:987>DCBA@?EJIHGFKONMLPSRQT=PSRQKONMLEJIHGF>DCBA@?6=<;:987-543210/.#,+*)('&%$"! TNone "#17_k@avro\Derives 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 typesavroNControls how we handle namespaces when defining Haskell type and field names.avro{Describes the representation of a field for a derived data type. The field will be derived as if it were written with an {- UNPACK -} pragma.avrovDescribes the strictness of a field for a derived data type. The field will be derived as if it were written with a !.avro<How to treat Avro namespaces in the generated Haskell types.avroNamespaces are ignored completely. Haskell identifiers are generated from types' base names. This produces nicer types but fails on valid Avro schemas where the same base name occurs in different namespaces.The Avro type com.example.Foo" would generate the Haskell type Foo. If Foo had a field called bar:, the generated Haskell record would have a field called fooBar.avroBHaskell types and field names are generated with namespaces. See deriveAvroWithNamespaces# for an example of how this works.The Avro type com.example.Foo" would generate the Haskell type ComexampleFoo. If Foo had a field called bar6, the generated Haskell record would have the field comexampleFooBar.avroProvide a custom mapping from the name of the Avro type and its namespace that will be used to generate Haskell types and fields.avroDefault deriving options defaultDeriveOptions =  { fieldNameBuilder =  , fieldStrictness =  , namespaceBehavior =  } avro;Generates a field name that is prefixed with the type name.(For example, if the schema defines type Person that has a field  firstName/, then the generated Haskell type will be like #Person { personFirstName :: Text } avro:Marks any field as non-strict in the generated data types.avroMake a field strict and unpacked if it has a primitive representation. Primitive types are types which GHC has either a static or an unlifted representation: `()`, , , , }, }.avrouGenerates a field name that matches the field name in schema (sanitised for Haskell, so first letter is lower cased)(For example, if the schema defines type Person that has a field  firstName/, then the generated Haskell type will be like Person { firstName :: Text } You may want to enable  if you want to use this method.avrouDerives Haskell types from the given Avro schema file. These Haskell types support both reading and writing to Avro.3For an Avro schema with a top-level record called com.example.Foo, this generates:a } with the name  schema'Foo or schema com'exampleFoo, depending on the  setting.7Haskell types for each named type defined in the schema HasSchema instances for each type instances for each type instances for each typeAThis function ignores namespaces when generated Haskell type and field names. This will fail on valid Avro schemas which contain types with the same base name in different namespaces. It will also fail for schemas that contain types with base names that are the same except for the capitalization of the first letter. The type com.example.Foo will generate a Haskell type Foo. If com.example.Foo has a field named Bar2, the field in the Haskell record will be called fooBar.avro0Derive Haskell types from the given Avro schema./For an Avro schema with a top-level definition com.example.Foo, this generates:a } with the name  schema'Foo or schema com'exampleFoo depending on namespace handling7Haskell types for each named type defined in the schema HasSchema instances for each type instances for each type instances for each typeavroSame as  but uses   deriveAvro =   avroSame as  but uses  deriveAvro' =   avroSame as , but takes a ByteString rather than FilePathavroGenerates the value of type }! that it can later be used with  or . EmySchema :: Schema mySchema = $(makeSchema "schemas/my-schema.avsc") avroA hack around TemplateHaskell limitation: It is currently not possible to splice variable name in QQ. This function allows to replace hardcoded name into the specified one.avroRenders a fully qualified Avro name to a valid Haskell identifier. This does not change capitalization make sure to capitalize as needed depending on whether the name is a Haskell type, constructor, variable or field.With 4, namespace components (if any) are separated with '. The Avro name "com.example.foo" would be rendered as comexamplefoo.With 9, only the base name of the type is used. The Avro name "com.example.foo" would be rendered as "foo".avro base nameavrocountavro8How to handle namespaces when generating the type name.avro7The name to transform into a valid Haskell identifier. !"#$%&'()*+,-./0123456789:;<=>?@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                                   ! " # $                % & ' ( ) * + , - . + / 0 1 / 2 3 2 4 5 6 7 8 9 : ; < = > ? @ 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 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{|}~~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      #avro-0.5.0.0-ABb84txpWbVKoJAyfnf0RsData.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-A5UuyZx9JzP9PhxgXRLyUTText.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 logicalTypeSitemvaluesnamealiasesdocorderfieldssymbolsoptionssize 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 $fEqOrder $fOrdOrder $fShowOrder$fGenericOrder $fNFDataOrder$fGenericDecimal$fNFDataDecimal$fEqLogicalTypeBytes$fShowLogicalTypeBytes$fOrdLogicalTypeBytes$fGenericLogicalTypeBytes$fNFDataLogicalTypeBytes$fEqLogicalTypeFixed$fShowLogicalTypeFixed$fOrdLogicalTypeFixed$fGenericLogicalTypeFixed$fNFDataLogicalTypeFixed$fEqLogicalTypeInt$fShowLogicalTypeInt$fOrdLogicalTypeInt$fGenericLogicalTypeInt$fNFDataLogicalTypeInt$fEqLogicalTypeLong$fShowLogicalTypeLong$fOrdLogicalTypeLong$fGenericLogicalTypeLong$fNFDataLogicalTypeLong$fEqLogicalTypeString$fShowLogicalTypeString$fOrdLogicalTypeString$fGenericLogicalTypeString$fNFDataLogicalTypeString $fEqTypeName $fOrdTypeName$fGenericTypeName$fNFDataTypeName $fOrdSchema $fShowSchema$fGenericSchema$fNFDataSchema $fEqField $fOrdField $fShowField$fGenericField $fNFDataField$fEqDefaultValue$fOrdDefaultValue$fShowDefaultValue$fGenericDefaultValue$fNFDataDefaultValue $fEqResult $fOrdResult $fShowResult$fGenericResult$fNFDataResult ReadField fldStatus FieldStatusAsIsIgnored Defaulted ReadSchema FreeUnion longReadFrom floatReadFromdoubleReadFromposty ReadDouble DoubleFromIntDoubleFromFloatDoubleFromLong ReadFloat FloatFromInt FloatFromLongReadLong LongFromInt fromSchema fromField$fShowReadLong $fEqReadLong $fOrdReadLong$fGenericReadLong$fNFDataReadLong$fShowReadFloat $fEqReadFloat$fOrdReadFloat$fGenericReadFloat$fNFDataReadFloat$fShowReadDouble$fEqReadDouble$fOrdReadDouble$fGenericReadDouble$fNFDataReadDouble$fShowFieldStatus$fEqFieldStatus$fOrdFieldStatus$fGenericFieldStatus$fNFDataFieldStatus $fEqReadField$fShowReadField$fGenericReadField$fNFDataReadField$fEqReadSchema$fShowReadSchema$fGenericReadSchema$fNFDataReadSchema 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 $fToAvroFloat$fToAvroDouble$fToAvroWord64$fToAvroWord32$fToAvroWord16 $fToAvroWord8 $fToAvroInt64 $fToAvroInt32 $fToAvroIntContainerHeader syncBytes decompresscontainedSchema nrSyncBytes newSyncBytesgetContainerHeaderdecodeRawBlocks getNextBlockextractContainerValuesBytesextractContainerValuespackContainerValuespackContainerValuesWithSyncpackContainerValuesWithSync'packContainerBlockspackContainerBlocksWithSynccontainerHeaderWithSyncconsumeN parseCodectakeWhileInclusiveFromAvrofromAvroValuegetValue$fFromAvroHashMap $fFromAvroMap$fFromAvroEither$fFromAvroMaybe$fFromAvroIdentity$fFromAvroVector$fFromAvroVector0 $fFromAvro[]$fFromAvroUTCTime$fFromAvroDiffTime $fFromAvroDay$fFromAvroUUID$fFromAvroDecimal$fFromAvroByteString$fFromAvroByteString0$fFromAvroText$fFromAvroBool$fFromAvroFloat$fFromAvroDouble$fFromAvroInt64$fFromAvroInt32 $fFromAvroInt $fEqValue $fShowValue$fGenericValue $fNFDataValueextractDerivablesgetTypes normSchema $fLiftHashMap $fLiftVector $fLiftText$fLiftByteString $fLiftSchema$fLiftLogicalTypeString$fLiftLogicalTypeLong$fLiftLogicalTypeInt$fLiftLogicalTypeFixed$fLiftLogicalTypeBytes $fLiftDecimal$fLiftTypeName $fLiftOrder $fLiftField$fLiftDefaultValuereadSchemaFromSchemaencodeValueWithSchema 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 $fEqEither3 $fOrdEither3 $fShowEither3$fGenericEither3$fFunctorEither3$fFoldableEither3$fTraversableEither3 $fEqEither4 $fOrdEither4 $fShowEither4$fGenericEither4$fFunctorEither4$fFoldableEither4$fTraversableEither4 $fEqEither5 $fOrdEither5 $fShowEither5$fGenericEither5$fFunctorEither5$fFoldableEither5$fTraversableEither5 $fEqEither6 $fOrdEither6 $fShowEither6$fGenericEither6$fFunctorEither6$fFoldableEither6$fTraversableEither6 $fEqEither7 $fOrdEither7 $fShowEither7$fGenericEither7$fFunctorEither7$fFoldableEither7$fTraversableEither7 $fEqEither8 $fOrdEither8 $fShowEither8$fGenericEither8$fFunctorEither8$fFoldableEither8$fTraversableEither8 $fEqEither9 $fOrdEither9 $fShowEither9$fGenericEither9$fFunctorEither9$fFoldableEither9$fTraversableEither9 $fEqEither10 $fOrdEither10$fShowEither10$fGenericEither10$fFunctorEither10$fFoldableEither10$fTraversableEither10 DeriveOptionsfieldNameBuilderfieldRepresentationnamespaceBehaviorFieldUnpackedness UnpackedFieldNonUnpackedFieldFieldStrictness StrictField LazyFieldNamespaceBehaviorIgnoreNamespacesHandleNamespacesCustomdefaultDeriveOptionsmkPrefixedFieldName mkLazyFieldmkStrictPrimitiveFieldmkAsIsFieldNamederiveAvroWithOptionsderiveAvroWithOptions' deriveAvro deriveAvro'deriveAvroFromByteString makeSchemamakeSchemaFromByteStringmakeSchemaFrom$fGenericFieldStrictness$fGenericFieldUnpackedness$fGenericDeriveOptionsChunkbinary-0.8.6.0Data.Binary.Get.InternalGet mkTypeNameparseSchemaJSON mkAliases parseField schemaToJSONparseFieldDefault text-1.2.3.1Data.Text.InternalTextbase Data.StringIsStringbytestring-0.10.8.2Data.ByteString.Internal ByteString describeValue convertValueGHC.IntInt32Int64ghc-boot-th-8.6.3GHC.LanguageExtensions.TypeDuplicateRecordFieldssetName renderNamenewNames