!jR      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None/ avro&Dynamically enforced monomorphic type. avro%Dynamically enforced monomorphic type avroGSet 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 symbol      SafeNone 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 symbol  None! None "#$%=?@APX_2avro=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").2 represents a fullname` a name combined with a namespace. These are written and parsed as dot-separated strings. The 2 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"6avrolAvro types are considered either primitive (string, int, etc) or complex/declared (structures, unions etc).RavroAn Avro schema is either * A "JSON object in the form `{"type":"typeName" ...` * A "JSON string, naming a defined type" (basic type wo free variables.names) * A "JSON array, representing a union"N.B. It is possible to create a Haskell value (of Schema type) that is not a valid Avro schema by violating one of the above or one of the conditions called out in \.Savro Build an 6 value from its components.TavromkUnion 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!Uavro,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 2/, 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.VavrogGet 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 R 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.YavroParse JSON-encoded avro data.ZavroParses 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 resolvable]avrobuildTypeEnvironment 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.aavro:Extract the named inner type definition as its own schema.cavroThis lets us write 22s 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.davro Show the 2* as a string literal compatible with its  instance. Savro*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.YavroHow 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 D 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.?#%$&)'(*+,-./0123456<;9C?>7@ED8:=BAQHFGIJKLMNOPRSTUVWXYZ[\]^_`a?R6<;9C?>7@ED8:=BAQHFGIJKLMNOP*+,-./01&)'(2345UST\V]_#%$WX^Z[Y`aNone$_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.None,=?XNone,=?XNonePavrodeconflict writer reader valy will convert a value that was encoded/decoded with the writer's schema into the form specified by the reader's schema.avro Writer schemaavro Reader schemaNone4 Noneavrodeconflict writer reader valy will convert a value that was encoded/decoded with the writer's schema into the form specified by the reader's schema.avro Writer schemaavro Reader schema SafeHV SafeA None=?X`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. None "#=?PX`None "#=?PX`6avroDecode bytes into a Value as described by Schema.SafeHVSafeXNone "#=?HVX avroCGenerates a new synchronization marker for encoding Avro containersavrobEncode chunks of objects into a container, using 16 random bytes for the synchronization markers.avro4Creates an Avro container header for a given schema.avroiEncode chunks of objects into a container, using the provided ByteString as the synchronization markers.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.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.#avro+Maybe is modeled as a sum type `{null, a}`.None,=?X`:;<:;<None,=?X`NavroN is a clone of FromAvro( except that it works for lazy values ().Decoding from ( directly without converting to strict Value and then FromAvro< can be very beneficial from the performance point of view.NOPNOPNone "#,=?PX` bavroEDecodes the container as a lazy list of values of the requested type.eThe schema for the requested type 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.cavroEDecodes the container as a lazy list of values of the requested type.eThe schema for the requested type will be de-conflicted with the schema embedded with the container.The content of the container is returned as a list of "blocks" of values inside this container, so the notion of blocks in the container is preserved. Since decoding is lazy it should be safe to concat these values into one lazy list.The "outer" error represents the error in opening the container itself (including problems like reading schemas embedded into the container.)DThe "inner" errors represent problems in decoding individual values.Note that this function will not stop decoding at the first occurance of the "inner" error, and will continue attempting decoding values, so it is possible to get  after }. It is up to the user to decide whether it is correct or not to continue after errors (most likely it will not be correct).b7 function makes a choice to stop after the first error.davroSame as bp but uses provided schema as a reader schema for the container instead of the schema obtained from the type of a.NIt is up to the user to make sure that the provided schema is compatible with a) and with the container's writer schema.eavroSame as cp but uses provided schema as a reader schema for the container instead of the schema obtained from the type of a.NIt is up to the user to make sure that the provided schema is compatible with a) and with the container's writer schema.favroDecode bytes into a Value as described by Schema.gavro?Decodes the container into a list of blocks of raw Avro values.The content of the container is returned as a list of "blocks" of values inside this container, so the notion of blocks in the container is preserved. Since decoding is lazy it should be safe to concat these values into one lazy list.Each  LazyValue can be an %] and this function doesn't make any attempts of dealing with them leaving it up to the user.The "outer" error represents the error in opening the container itself (including problems like reading schemas embedded into the container.)havroQReads 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.)javro?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.kavrowSplits 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.!   WNOPbcdefghijkl!fbcdehgijklNOP   WNone,=?X`Pnavro<Decode a lazy bytestring using a Schema for the return type.oavro/Decode a lazy bytestring with a provided schemapavrogDecode a container and de-conflict the writer schema with a reader schema for a return type. Like in q% exceptions are thrown instead of a #Q type to allow this function to be read lazy (to be done in some later version).qavrovDecode a container and de-conflict the writer schema with a given reader-schema. Exceptions are thrown instead of a #Q type to allow this function to be read lazy (to be done in some later version).ravro$Encodes a value to a lazy ByteStringsavrobEncode chunks of objects into a container, using 16 random bytes for the synchronization markers.tavrohEncode chunks of objects into a container, using the provided ByteString as the synchronization markersuavroLike pb but returns the avro-encoded bytes for each object in the container instead of the Haskell type.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.#%$RW:;<mnopqrstuvw:;Rm<vw#%$WnopqurstNoneX yavro Convert a b into a type that has an Avro schema. The schema is used to validate the JSON and will return an %K if the JSON object is not encoded correctly or does not match the schema.zavroParse a D as JSON and convert it to a type with an Avro schema. Will return %X if the input is not valid JSON or the JSON does not convert with the specified schema.{avro@Convert an object with an Avro schema to JSON using that schema.We always need the schema to encodeN to JSON because representing unions requires using the names of named types.xyz{xyz{None4567X|~}|~}None "#%7_iavro\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.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: `()`, 8, , , 6, 6.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 R 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 R 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 typeavro]Derives "read only" Avro from a given schema file. For a schema with a top-level definition com.example.Foo, this generates:a R value with the name  schema'Foo7Haskell types for each named type defined in the schema HasSchema instances for each type: instances for each typeavropDerive "read only" Haskell types from the given Avro schema with configurable behavior for handling namespaces./For an Avro schema with a top-level definition com.example.Foo, this generates:a R 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 typeavroSame as  but uses   deriveAvro =   avroSame as  but uses  deriveAvro' =   avroSame as  but uses . @deriveFromAvro = deriveFromAvroWithOptions defaultDeriveOptions avroGenerates the value of type R! 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.Safej- !"#$%&'()*+,-. !"#$%&'()*/012+34567789:;<=>?@AB !"#$%&C'*()DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~             !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh_ijklmnopqrstuvwxyz{|}~.#avro-0.4.1.1-Ikc1ssdOldDHEMIFPpHOstData.Avro.Decode.Lazy.LazyValueData.Avro.Types.ValueData.Avro.SchemaData.Avro.Deriving.NormSchemaData.Avro.HasAvroSchemaData.Avro.ToAvroData.Avro.DeconflictData.Avro.Decode.Lazy.Convert Data.Avro.Decode.Lazy.Deconflict Data.Avro.ZagData.Avro.DecodeRawData.Avro.Decode.Get Data.Avro.Decode.Strict.InternalData.Avro.Decode Data.Avro.ZigData.Avro.EncodeRawData.Avro.EncodeData.Avro.FromAvro"Data.Avro.Decode.Lazy.FromLazyAvroData.Avro.Decode.Lazy Data.AvroData.Avro.JSONData.Avro.EitherNData.Avro.DerivingData.Avro.Decode.StrictData.Avro.Types Paths_avro LazyValueNullBooleanIntLongFloatDoubleBytesStringArrayMapRecordUnionFixedEnumError $fEqLazyValue$fShowLazyValueValue $fEqValue $fShowValueResultSuccessOrder Ascending DescendingIgnoreFieldfldName fldAliasesfldDocfldOrderfldType fldDefaultTypeNameTNbaseName namespaceType NamedTypeitemvaluesnamealiasesdocorderfieldssymbols symbolLookupoptions unionLookupsizeSchemamkEnummkUnionrenderFullnametypeNamebadValueresultToEither parseAvroJSON parseBytesserializeBytesvalidateSchemabuildTypeEnvironmentmatchesextractBindingsoverlay subdefinition$fHashableTypeName$fIsStringTypeName$fShowTypeName$fFromJSONOrder $fToJSONOrder $fToJSONValue $fToJSONType$fFromJSONType$fEqType$fTraversableResult$fFoldableResult$fMonoidResult$fSemigroupResult$fMonadPlusResult$fAlternativeResult$fApplicativeResult$fMonadError[]Result$fMonadFailResult$fFunctorResult $fMonadResult $fEqTypeName $fOrdTypeName $fEqOrder $fOrdOrder $fShowOrder $fShowType $fEqField $fShowField $fEqResult $fOrdResult $fShowResultextractDerivablesgetTypes normSchema HasAvroSchemaschemaschemaOfwrapTag$fHasAvroSchemaSet$fHasAvroSchemaVector$fHasAvroSchemaVector0$fHasAvroSchemaArray$fHasAvroSchema[]$fHasAvroSchemaMaybe$fHasAvroSchemaHashMap$fHasAvroSchemaMap$fHasAvroSchemaHashMap0$fHasAvroSchemaMap0$fHasAvroSchemaHashMap1$fHasAvroSchemaMap1$fHasAvroSchemaEither$fHasAvroSchemaByteString$fHasAvroSchemaByteString0$fHasAvroSchemaText$fHasAvroSchemaText0$fHasAvroSchemaFloat$fHasAvroSchemaDouble$fHasAvroSchemaInt64$fHasAvroSchemaInt32$fHasAvroSchemaInt16$fHasAvroSchemaInt8$fHasAvroSchemaInt$fHasAvroSchema()$fHasAvroSchemaBool$fHasAvroSchemaWord64$fHasAvroSchemaWord32$fHasAvroSchemaWord16$fHasAvroSchemaWord8ToAvrotoAvro.=$fToAvroVector$fToAvroVector0 $fToAvro[] $fToAvroMaybe$fToAvroHashMap $fToAvroMap$fToAvroHashMap0 $fToAvroMap0$fToAvroHashMap1 $fToAvroMap1$fToAvroEither$fToAvroByteString$fToAvroByteString0 $fToAvroText $fToAvroText0 $fToAvroFloat$fToAvroDouble $fToAvroInt64 $fToAvroInt32 $fToAvroInt $fToAvro() $fToAvroBool deconflict toStrictValuefromStrictValueZagZaggedzag $fZagWord $fZagWord64 $fZagWord32 $fZagWord16 $fZagWord8 DecodeRaw decodeRaw$fDecodeRawInt64$fDecodeRawInt32$fDecodeRawInt16$fDecodeRawInt8$fDecodeRawInt$fDecodeRawWord64$fDecodeRawWord32$fDecodeRawWord16$fDecodeRawWord8$fDecodeRawWordContainerHeader syncBytes decompresscontainedSchemaGetAvrogetAvro nrSyncBytesgetCodec getBooleangetIntgetLong getZigZaggetBytes getStringgetFloat getDoublegetArraygetMap sFromIntegral $fGetAvroSet$fGetAvroVector$fGetAvroArray$fGetAvroMaybe $fGetAvro[] $fGetAvro[]0$fGetAvroDouble$fGetAvroFloat $fGetAvroText$fGetAvroByteString$fGetAvroByteString0$fGetAvroInt64$fGetAvroInt32 $fGetAvroBool $fGetAvroMap$fGetAvroContainerHeader getAvroOf decodeAvrodecodeContainerdecodeContainerWithZigZiggedzig$fZigInt $fZigInt64 $fZigInt32 $fZigInt16 $fZigInt8 EncodeRaw encodeRaw$fEncodeRawInt64$fEncodeRawInt32$fEncodeRawInt16$fEncodeRawInt8$fEncodeRawInt$fEncodeRawWord64$fEncodeRawWord32$fEncodeRawWord16$fEncodeRawWord8$fEncodeRawWord EncodeAvroavro encodeAvro newSyncBytesencodeContainercontainerHeaderWithSyncencodeContainerWithSyncpackContainerBlockspackContainerBlocksWithSyncpackContainerValuespackContainerValuesWithSyncputAvro getSchema$fEncodeAvroValue$fEncodeAvroBool$fEncodeAvro()$fEncodeAvroMaybe$fEncodeAvroHashMap$fEncodeAvroSet$fEncodeAvroVector$fEncodeAvroVector0$fEncodeAvroArray$fEncodeAvro[]$fEncodeAvroFloat$fEncodeAvroDouble$fEncodeAvro[]0$fEncodeAvroByteString$fEncodeAvroByteString0$fEncodeAvroText$fEncodeAvroText0$fEncodeAvroWord64$fEncodeAvroWord32$fEncodeAvroWord16$fEncodeAvroWord8$fEncodeAvroInt64$fEncodeAvroInt32$fEncodeAvroInt16$fEncodeAvroInt8$fEncodeAvroIntFromAvrofromAvro.:$fFromAvroHashMap $fFromAvroMap$fFromAvroText$fFromAvroText0$fFromAvroVector$fFromAvroVector0 $fFromAvro[]$fFromAvroMaybe$fFromAvroFloat$fFromAvroDouble$fFromAvroInt64$fFromAvroInt32 $fFromAvroInt$fFromAvroByteString$fFromAvroByteString0$fFromAvroBool$fFromAvroEither FromLazyAvro fromLazyAvro.~:$fFromLazyAvroHashMap$fFromLazyAvroMap$fFromLazyAvroText$fFromLazyAvroText0$fFromLazyAvroVector$fFromLazyAvroVector0$fFromLazyAvro[]$fFromLazyAvroMaybe$fFromLazyAvroFloat$fFromLazyAvroDouble$fFromLazyAvroInt64$fFromLazyAvroInt32$fFromLazyAvroInt$fFromLazyAvroByteString$fFromLazyAvroByteString0$fFromLazyAvroBool$fFromLazyAvroEitherdecodeContainer'decodeContainerWithSchemadecodeContainerWithSchema'getContainerValuesdecodeRawBlocksgetContainerValuesWithgetContainerValuesBytesgetContainerValuesBytes'AvrodecodedecodeWithSchemaencodedecodeContainerBytesrecordfixeddecodeAvroJSONfromJSON parseJSONtoJSONEither5E5_1E5_2E5_3E5_4E5_5Either4E4_1E4_2E4_3E4_4Either3E3_1E3_2E3_3$fToAvroEither3$fFromLazyAvroEither3$fFromAvroEither3$fHasAvroSchemaEither3$fBitraversableEither3$fBifoldableEither3$fMonadEither3$fBifunctorEither3$fApplicativeEither3$fToAvroEither4$fFromLazyAvroEither4$fFromAvroEither4$fHasAvroSchemaEither4$fBitraversableEither4$fBifoldableEither4$fMonadEither4$fBifunctorEither4$fApplicativeEither4$fToAvroEither5$fFromLazyAvroEither5$fFromAvroEither5$fHasAvroSchemaEither5$fBitraversableEither5$fBifoldableEither5$fMonadEither5$fBifunctorEither5$fApplicativeEither5 $fEqEither3 $fOrdEither3 $fShowEither3$fGenericEither3$fFunctorEither3$fFoldableEither3$fTraversableEither3 $fEqEither4 $fOrdEither4 $fShowEither4$fGenericEither4$fFunctorEither4$fFoldableEither4$fTraversableEither4 $fEqEither5 $fOrdEither5 $fShowEither5$fGenericEither5$fFunctorEither5$fFoldableEither5$fTraversableEither5 DeriveOptionsfieldNameBuilderfieldRepresentationnamespaceBehaviorFieldUnpackedness UnpackedFieldNonUnpackedFieldFieldStrictness StrictField LazyFieldNamespaceBehaviorIgnoreNamespacesHandleNamespacesdefaultDeriveOptionsmkPrefixedFieldName mkLazyFieldmkStrictPrimitiveFieldmkAsIsFieldNamederiveAvroWithOptionsderiveAvroWithOptions'deriveFromAvroWithOptions deriveAvro deriveAvro'deriveFromAvro makeSchemamakeSchemaFrom$fGenericFieldStrictness$fGenericFieldUnpackedness$fGenericDeriveOptions parseFullname mkTypeNameparseSchemaJSON mkAliases parseField schemaToJSONparseFieldDefault text-1.2.3.1Data.Text.InternalTextbase Data.StringIsString Data.EitherRightLeftbytestring-0.10.8.2Data.ByteString.Internal ByteString$aeson-1.4.2.0-Dz6dKHDZe0i7POALa578tqData.Aeson.Types.InternalData.ByteString.Lazy.InternalGHC.IntInt32Int64ghc-boot-th-8.6.1GHC.LanguageExtensions.TypeDuplicateRecordFieldsderiveFromAvroWithOptions'setName renderNamenewNamesversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName