>      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                ! " # $ % & ' ()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                  ! " # $ % & ' ( ) * + , - . / 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 { | } ~                                                                                       !!!!'None  None QEncode an element of a union as single-element map from a field name to a value.    NoneThe "oh noes!" operator.LAttempts to match the keys of the maps to produce a map from keys to pairs.    None!"I"EBinary data is represented in JSON format as a base64-encoded string A default value for a field';the basic JSON types (N.B., no floating point numbers, yet)(a JSON UTF-8 string)a base-64-encoded byte string* a JSON bool+a JSON integral number,a JSON UTC string-HType is either a list, Maybe, a named element of the API or a basic type.list elements are types/Maybe elements are types0.the referenced type must be defined by the API1a JSON string, int, bool etc.2a generic JSON value3Conversion possibly converts to an internal representation. If specified, a conversion is a pair of an injection function name and a projection function name.4(SpecEnum is your classic enumerated type7%SpecUnion is your classsic union type:In addition to the type and comment, record fields may carry a flag indicating that they are read-only, and may have a default value, which must be of a compatible type.@)SpecRecord is your classsic product type.SESpecNewtype elements are isomorphisms of string, inetgers or booleansWrtype/element specs are either simple type isomorphisms of basic JSON types, records, unions or enumerated types]ia distinct case-insensitive short prefix used to form unique record field names and data constructors:"must be a valid Haskell identifiermust be unique within the API^,Markdown comments are represented by strings_FieldName identifies recod fields and union alternatives must contain a valid identifier valid in Haskell and any API client wrappers (e.g., if Ruby wrappers are to be generated the names should easily map into Ruby)b6TypeName must contain a valid Haskell type constructore/Specifies an individual element/type of the APIgname of Haskell typeh#comment describing type in Markdowni!distinct short prefix (see below)jthe type specificationkoptional conversion functionsokan API spec is made up of a list of type/element specs, each specifying a Haskell type and JSON wrapperss$Convert a default value to an Aeson . This differs from  as it will not round-trip with .: UTC default values are turned into strings.|AIt is sometimes helpful to write a type name directly as a string !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~X !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstXolmnefghijkbcd_`a^]WXYZ[\STUV@AB:;<=>?7894563-./012 !"#$%&'()*+,OPQRKLMNGHIJCDEFsrpqtZ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneA  aF is something that can generate TH declarations from a value of type a#. Tools can be combined using the  instance.0Execute a tool to generate some TH declarations.Settings to control the behaviour of API tools. This record may be extended in the future, so you should construct a value by overriding individual fields of .UGenerate a warning when an instance declaration is omitted because it already existsiRename the constructors of filtered newtypes and generate smart constructors that enforce the invariants+Default settings designed to be overridden.5Construct a tool that does not depend on any settings0Construct a tool that may depend on the settings is a contravariant functor8Make a tool that reads its argument to decide what to do?Apply a tool that acts on elements of a list to the entire list0Apply a tool that acts on nodes to an entire API]Apply a tool that acts on datatype nodes (i.e. those that are not synonyms) to an entire APIFCreate a tool that acts on nodes from its action on individual specs."NoneNoneRConstruct an idiomatic expression (an expression in an Applicative context), i.e. Napp ke [] = ke app ke [e1,e2,...,en] = ke <$> e1 <*> e2 ... <*> enTAdd an instance declaration for a class, if such an instance does not already exist-Construct a TH function with a type signature Construct a simple TH definition6Construct a simple TH definition with a type signature!Field name as a string expressionField name as a variable    NoneDTool to generate datatypes and type synonyms corresponding to an APITool to generate datatypes and type synonyms corresponding to an API, where the function specifies the derived classes for each datatype."Generate a type synonym definition)Generate a newtype definition, like this: Snewtype JobId = JobId { _JobId :: T.Text } deriving (Show,IsString,Eq,Typeable)YIf a filter has been applied, and smart constructors are enabled, instead generate this: newtype EmailAddress = UnsafeMkEmailAddress { _EmailAddress :: T.Text } deriving (Show,Eq,Typeable) mkEmailAddress :: T.Text -> Maybe EmailAddress mkEmailAddress t = ... -- check filter-Generate a record type definition, like this: data JobSpecId = JobSpecId { _jsi_id :: JobId , _jsi_input :: JSInput , _jsi_output :: JSOutputStatus , _jsi_pipelineId :: PipelineId } deriving (Show,Eq,Typeable),Generate a union type definition, like this: >data Foo = F_Bar Int | F_Baz Bool deriving (Show,Typeable),Generate an enum type definition, like this: data FrameRate = FR_auto | FR_10 | FR_15 | FR_23_97 | FR_24 | FR_25 | FR_29_97 | FR_30 | FR_60 deriving (Show,Eq,Ord,Bounded,Enum,Typeable)[Default names of classes for which to derive instances, depending on the type of API node. 5Name of the type corresponding to the API node, e.g. JobId WName of the representation type corresponding to the API node, which differs from the  ~ only if custom conversion functions are specified. This is also the name of the sole constructor for newtypes and records.HName of the single field in a newtype, prefixed by an underscore, e.g. _JobIdName of the constructor of a newtype, which will be same as the representation type unless a smart constructor is requested, in which case we just prefix it with UnsafeMk.?Name of the smart constructor of a newtype, prefixed with "mk".`Construct the name of a record field by attaching the type-specific prefix, in lowercase, e.g. _jsi_idmConstruct the name of a union or enum constructor by attaching the type-specific prefix, in uppercase, e.g. FR_auto %The type corresponding to an API node 4The representation type corresponding to an API node %The constructor for a record API node5The constructor for a newtype, which might be renamed/A record field in an API node, as an expression+A record field in an API node, as a pattern<A prefixed constructor for a union or enum, as an expression8A prefixed constructor for a union or enum, as a patternAThe projection function from a newtype API node, as an epxression                    None2Tool to make lenses for fields in generated types. NoneTool to derive W instances for generated types. At present, this derives only base version instances. NoneTool to generate  instances for generated types. None3Tool to generate the maps between enumerations and Text strings named by  and .For an enum type E, name a function _text_E :: E -> Textq that gives a string corresponding to the inhabitant of the type. For example, we generate something like this: j _text_FrameRate :: FrameRate -> T.Text _text_FrameRate fr = case fr of FRauto -> "auto" FR10 -> "10" FR15 -> "15" FR23_97 -> "23.97" FR24 -> "24" FR25 -> "25" FR29_97 -> "29.97" FR30 -> "30" FR60 -> "60"For an enum type E, name a map from Text1 values to inhabitants of the type, for example: P_map_FrameRate :: Map Text FrameRate _map_FrameRate = genTextMap _text_FrameRate NoneTool to generate # instances for types generated by . This depends on .          None6bThe Example class is used to generate a documentation-friendly example for each type in the model*Generator for example values; defaults to  if not specifiedGenerate a list of (type name, sample generator) pairs corresponding to each type in the API, with samples encoded as JSON. This depends on the  instances generated by $. It generates something like this: \samples :: [(String, Gen Value)] samples = [("Foo", fmap toJSON (example :: Gen Foo)), ... ]Tool to generate # instances for types generated by . This depends on quickCheckTool. Generate an 7 instance for a newtype. If there is no filter, call ) on the underlying type; otherwise, use . Like S, if a regular expression filter is applied the instance must be defined manually. Generate an  instance for a record: instance Example Foo where example = sized $ \ x -> Foo <$> resize (x `div` 2) example <*> ... <*> resize (x `div` 2) example Generate an  instance for a union: Uinstance Example Foo where example = oneOf [ fmap Bar example, fmap Baz example ] Generate an : instance for an enumeration, with no definition for the 2 method, because we can inherit the behaviour of : instance Example Foo !"#$%&' !"#$%&'None(Tool to generate  instances for generated types. Generate an  instance for a newtype that respects its filter. We don't try to generate arbitrary data matching a regular expression, however: instances must be supplied manually. When generating arbitrary integers, use  rather than 3 (the latter tends to generate non-unique values). Generate an  instance for a record: instance Arbitrary Foo where arbitrary = sized $ \ x -> Foo <$> resize (x `div` 2) arbitrary <*> ... <*> resize (x `div` 2) arbitrary Generate an  instance for a union: ]instance Arbitrary Foo where arbitrary = oneOf [ fmap Bar arbitrary, fmap Baz arbitrary ] Generate an  instance for an enumeration: @instance Arbitrary Foo where arbitrary = elements [Bar, Baz]Generate an arbitrary  in a given range.Generate an arbitrary s in a given range. TODO: we might want to generate a broader range of sample times, rather than just the extrema.()((()#NoneBBEncode a Haskell String to a list of Word8 values, in UTF8 format. !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~2-AT>:KCLN@.JE=/0123456789;<?BDFGHIMOPQRSUVWXYZ[\kvY !"#$%&'()*+,-,./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None9;*+,-./0123456789:;*+,-./,-*+./*+,-./0123456789:;None<"...and an enum is a set of values.=<...similarly a union is a map from fields to alternatives...>FThe canonical form of a record type is a map from fields to values...?8The normal or canonical form for a type declaration, an e=. Equality of the normal form indicates equivalence of APIs.We track all types.ETThe API type has too much extra info for us to be able to simply compare them with (==)x. Our strategy is to strip out ancillary information and normalise into a canonical form, and then we can use a simple (==) compare.Our normalised API discards most of the details of each type, keeping just essential information about each type. We discard order of types and fields, so we can use just associative maps.FECompute the normal form of an API, discarding extraneous information.G5Compute the normal form of a single type declaration.H)Find the set of type names used in an APII0Find the set of type names used in a declarationJ*Find the set of type names used in an typeK&Check if a type is declared in the APIL+Check if a type is used anywhere in the APIMJCheck if the first type's transitive dependencies include the second typeN5Compute the transitive dependencies of a set of typesOFCompute the set of types that depend (transitively) on the given typesCompute the transitive closure of a relation. Relations are represented as functions that takes a set of elements to the set of related elements.PrTest that all the free type names in a type are declared in the API. If not, return the set of undeclared types.QyTest that all the types used in a type declaration are declared in the API. If not, return the set of undeclared types.RcTest that all the types used in the API are declared. If not, return the set of undeclared types.S0Substitute types for type names in a declarationT)Substitute types for type names in a typeU6Rename the first type to the second throughout the API<=>?@ABCDEFGHIJKLMNOPQRSTUVW<=>?@ABCDEFGHIJKLMNOPQRSTUE?@ABCD>=<FGHIJKLMNORQPSTU<=>?@ABCDEFGHIJKLMNOPQRSTUVWNoneOTZbBuild a traversal of the root type (first argument) that updates values of the second type, e.g. traversalTool Root Sub produces DtraverseSubRoot :: Applicative f => (Sub -> f Sub) -> Root -> f Root=along with similar functions for all the types nested inside Root that depend on Sub.Note that types with custom representations will not have traversals generated automatically: if required, these must be defined manually in the same module as the call to Z:, otherwise the generated code will lead to scope errors.traversalName x tn- is the name of the function that traverses x values inside tntraversalType x an- is the type of the function that traverses x values inside an>Construct a traversal of the X substructures of the given typeKConstruct a traversal of the X substructures of the given type, or return * if there are no substructures to traverse{Build a traversal for a record type that applies f to any fields of type X, and traverses nested structures. For example: traverseXFoo :: Applicative f => (X -> f X) -> Foo -> f Foo traverseXFoo f x = Foo <$> f (foo_a x) <*> traverseXBar (traverse f) (foo_b x)RBuild a traversal for a union type that traverses nested structures. For example: traverseXBar :: Applicative f => (X -> f X) -> Bar -> f Bar traverseXBar f (BAR_one a) = BAR_one <$> f a traverseXBar f (Bar_two b) = BAR_two <$> traverseXBaz f bZZZZNone!"b:Create human-readable API documentation in Markdown formatc8Document a single API comment or node in Markdown format[\]^_`abc [\]^_`abc b[\]^_`ac[\]^_`abc$None!"2&dPRecord of arguments that must be supplied to generate HTML documentation for a f4URL for individual call documentation from the indexg$URL for documentation of an API typeh Type for l4 response body, parameterised by possible JSON typesiAn empty responsej!A JSON response of the given typekA non-empty, non-JSON responselExample response data from a n*HTTP status code for this example responseoType of example responsepContent of response, or  for empty responseq<Documents a specific view of the result data available in a s View nametType of result data returneduFree-form text descriptionv3Query parameters that may be supplied for this vieww<Documents a URL query parameter that may be included with a yParameter namezExample value for parameter{Free-form text description|Type of data in the parameter}%Is including the parameter mandatory?~2Documents a HTTP header that may be supplied to a  Header nameExample value for headerFree-form text descriptionType of data in header3Is including the header with the request mandatory?ADocuments a single method call on a resource in a web applicationHTTP method being documented!Relative URL path of the resourceFree-form text description%Does the call require authentication?!HTTP headers relevant to the call Type and example of request body%Query parameters relevant to the call"Available views of the result dataExample responses2defghijklmnopqrstuvwxyz{|}~2defghijklmnopqrstuvwxyz{|}~ defghijklmnopqrstuvwxyz{|}~ None%None!"(Generate a web page documenting all the s in a web application  &None!""Generate a web page documenting a None4defghijklmnopqrstuvwxyz{|}~4~wxyz{|}qrstuvlmnophijkdefgNone26 CAn initial API, an APIChange and the positions in which to apply it5Request to validate the dataset against the given API5Represents the positions in a type to apply an update<Represents the positions in a declaration to apply an updateRepresents either a released version (with a version number) or the version under development, which is newer than any releaseaWithin the changelog, custom migrations are represented as strings, so we have less type-safety."A single change within a changelogAn API changelog, consisting of a list of versions with the changes from one version to the next. The versions must be in descending order (according to the   instance).9The changes from the previous version up to this version.The initial version(%% None26 2Errors that may occur applying a single API changefor adding or renaming typefor deleting or renaming a typee.g. it's not a record type.cannot delete/modify types that are still used"type refers to a non-existent type"decl refers to a non-existent typefor adding or renaming a field for deleting or renaming a fieldGfor adding a field, must be a default value compatible with the typefor adding a field to a tablecustom error in tableChange9Errors that may be discovered when validating a changelog5the changelog must be in descending order of versions7forbid migrating from one version to an earlier version'an API uses types that are not declaredchangelog entry does not applyTchangelog is incomplete (ie all entries apply ok but result isn't the target api) 8Errors that can be discovered when migrating data values Data doesn't match schema 'Error generated during custom migration An API change was invalid OEach step may be into a field of an object, or a specific element of an array.xA position inside a JSON value is a list of steps, ordered innermost first (so going inside an object prepends a step).#Special format expected of a string^JSON type expected at a particular position, when a value of a different type was encountered=At present, we do not distinguish between errors and warnings9Represents an error that can be encountered while parsing-0Human-readable description of a JSON parse error/9Human-readable description of a single step in a position0KHuman-readable presentation of a list of parse errors with their positionszPerform a topological sort of the differences, so that the pretty-printed form can be copied directly into the changelog.v      !"#$%&'()*+,-./0123456789:NPRTVc      !"#$%&'()*+,-./01234l !"#$%& .0-/'()*+,    1234-"       !"#$%&'()*+,-./0123456789:NPRTVNone26WLike FromJSON, but keeping track of multiple errors and their positions. Moreover, this class is more liberal in accepting invalid inputs:a string like "3" is accepted as an integer; and the integers 0 and 1 are accepted as booleans.XYParse a JSON value with structured error-reporting support. If this method is omitted, fromJSONJ will be used instead: note that this will result in less precise errors.Y2Options to modify the behaviour of the JSON parserZ`If true, default values from the schema will be used when a field is missing from the JSON data[WIf true, fields in the schema marked read-only will be overwritten with default values\_If true, parse errors will be generated when invalid values are supplied for filtered newtypes]Like _, but keeping track of locations within the JSON structure and able to report multiple errors. Careful! The " instance does not agree with the 8 instance in all circumstances, and you should use the * instance where possible. In particular: pf <*> ps# returns errors from both arguments pf `ap` ps returns errors from pf only^=Use this as a basis for overriding individual fields of the Y4 record, in case more flags are added in the future._{Run a parser with given flags, starting in the outermost location, and returning warnings even if the parse was successful`Run the JSON parser on a value to produce a result or a list of errors with their positions. This should not be used inside an implementation of X. as it will not pass on the current position.awRun the JSON parser on a value to produce a result or a list of errors with their positions. This version allows the Y to be specified.bwRun the JSON parser on a value to produce a result or a list of errors with their positions. This version allows the YE to be specified, and produces warnings even if the parse succeeded.c Decode a  ByteString and run the JSON parserd Decode a  ByteString( and run the JSON parser, allowing the Y to be specifiede!Suitable as an implementation of  parseJSON that uses the W9 instance (provided said instance was not defined using fromJSON!).dIf this parser returns any errors at the current position, modify them using the supplied function.If the conditional is false, fail with an error (if filters are not being enforced) or report a warning and continue (if they are).hIt's contrary to my principles, but I'll accept a string containing a number instead of an actual number, and will silently truncate floating point numbers to integers...q=Look up the value of a field, treating missing fields as nullr_Look up the value of a field, which may be read-only or use a default value (depending on the Y).7Look up the value of a field, failing on missing fieldss;Parse the value of a field, treating missing fields as nullt5Parse the value of a field, failing on missing fieldsuMatch an inhabitant of a disjoint union, which should be an object with a single field, and call the continuation corresponding to the field name.7WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~B  !"#$%&'()*+,-/0WXYZ[\]^_`abcdefghijklmnopqrstuC]YZ[\^_WXX`abcdefhijklmnopqrstu !"#$%& 0-/g'()*+,0WXXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneTool to generate  and W# instances for types generated by . This depends on 1. For historical reasons this does not generate & instances; you probably want to use  instead.Tool to generate ,  and W# instances for types generated by . This depends on . Note that generated  and WH instances will always agree on the decoding of a value, but that the W2 instances for basic types are more liberal than .Tool to generate  instance for an API nodeTool to generate 0 instance for an API node, which relies on the W instance.Tool to generate W instance for an API node Generate  instances like this: 8instance FromJSON T where parseJSON = parseJSONDefault          None?A record is represented as a list of (field name, value) pairs.TInvariant: these are in ascending order by field name, and there are no duplicates.*TODO: consider if it would be worth using  instead.vGeneric representation of a data value belonging to a schema type. This representation has the following properties::it is straightforward to convert into either CBOR or JSON;decoding CBOR or parsing JSON requires the schema, and takes advantage of it by introducing type distinctions and interning field names;&decoding CBOR is relatively efficient. Convert a   into a generic , failing if the type is not compatible. This requires type information so that it can introduce type distinctions absent in   , e.g. when ! is used at type / (. t).Parse a generic  from a JSON k, given the schema and expected type. This is not particularly optimized. For the other direction, use .Efficiently encode a generic  in CBOR format.%Efficiently decode CBOR as a generic &, given the schema and expected type.wCheck that the value is of the given type in the schema, reporting the first error encountered if it does not conform.lGiven a schema, generate an arbitrary type corresponding to the schema and an arbitrary value of that type.EGiven a schema and a type, generate an arbitrary value of that type.'A reasonably varied generator for JSON s.Hack alert: we do not generate %, because Aeson fails to round-trip   ::  .&QuickCheck property that converting a 1 to and from JSON gives back the original value.QuickCheck property that the type-specific JSON serialisation agrees with deserialising as generic JSON and then serialising again.&QuickCheck property that converting a 1 to and from CBOR gives back the original value.QuickCheck property that the type-specific CBOR serialisation agrees with deserialising as generic CBOR and then serialising again.CLook up a type in a schema, failing with an error if it is missing.Look up a key in a set, returning a pointer to the set's copy of the key. This is useful during deserialisation because it means we can share a single key, avoiding retaining deserialised copies.Look up a key in a map, returning both the value and the map's copy of the key. This is useful during deserialisation because it means we can share a single key, avoiding retaining deserialised copies.Insert a (field, value) pair into a record, replacing the existing field if it is present and preserving the ordering invariant.KDelete a field from a record, trivially preserving the ordering invariant.>Rename a field in a record, preserving the ordering invariant.}Split a record at a given field, returning the preceding fields, value and succeeding fields. Fails if the field is absent.hJoin together two records with a (field, value) pair in between. The ordering invariant is not checked!: !"#$%++,  !"#$%None"XWhen to validate the data against the schema (each level implies the preceding levels): Not at all!At start and end of the migrationAfter custom migrationsAfter every change}Custom migrations used in the changelog must be implemented in Haskell, and supplied in this record. There are three kinds:^Whole-database migrations, which may arbitrarily change the API schema and the data to match;BType migrations, which may change the schema of a single type; anduSingle field migrations, which may change only the type of the field (with the new type specified in the changelog).hFor database and type migrations, if the schema is unchanged, the corresponding function should return .The db, ty and fldL parameters should be instantiated with the enumeration types generated by U, which correspond to the exact set of custom migration tags used in the changelog.Migrate a dataset from one version of an API schema to another. The data must be described by a named type, the name of which is assumed not to change.The db, rec and flda types must be enumerations of all the custom migration tags in the changelog, as generated by generateMigrationKind.:Lift a custom record migration to work on arbitrary valuesKLift a schema change on record types to work on arbitrary type declarationsUse for ,  or 7 to indicate that changes to the data are not requiredUse for  or 3 to indicate that the schema should not be changed&1Whether to validate the dataset after this change%The earliest version in the changelog#The latest version in the changelog'KChangelog in order starting from oldest version up to newest. Entries are  (from, to, changes-oldest-first).(pChangelog in order as written, with latest version at the beginning, going back to older versions. Entries are  (to, from, changes-latest-first).)WIs the changelog in the correct order? If not, return a pair of out-of-order versions.*mSets of custom migration tags in the changelog for whole-database, single-record and single-field migrations+0Sets of custom migration tags in a single change,^Given a type to be modified, find the positions in which each type in the API must be updatedXCheck that a changelog adequately describes how to migrate from one version to another.-Internal version of @, which works on unsafe migration tags and returns the list of s to apply to the dataset..Apply a list of changes to an API, returning the updated API and a list of the changes with appropriate TableChanges interspersed. On failure, return the list of successfully applied changes, the change that failed and the reason for the failure./Apply the API change05This is the low level one that just does the changes.VWe assume the changes have already been validated, and that the data matches the API.1>Apply an update at the given position in a declaration's value26Apply an upate at the given position in a type's value3`This actually applies the change to the data value, assuming it is already in the correct place4>Apply an update at the given position in a declaration's value57Apply an update at the given position in a type's value6`This actually applies the change to the data value, assuming it is already in the correct place7`Check if there is a "default" default value for a field of the given type: list and maybe have [] and nothingq respectively. Note that type synonyms do not preserve defaults, since we do not have access to the entire API.Check that a dataset matches an API, which is necessary for succesful migration. The name of the dataset's type must be specified.jGenerate enumeration datatypes corresponding to the custom migrations used in an API migration changelog.?89Starting schema and versionEnding schema and version(Log of changes, containing both versionsCustom migration functionsName of the dataset's type"How thoroughly to validate changesDataset to be migratedStarting schema and versionEnding schema and version(Log of changes, containing both versionsCustom migration functionsName of the dataset's type"How thoroughly to validate changesDataset to be migrated:&'()*+,Starting schema and versionEnding schema and versionChangelog to be validatedCustom migration functionsName of the dataset's type"How thoroughly to validate changes-Starting schema and versionEnding schema and versionChangelog to be validatedCustom migration functionsName of the dataset's type"How thoroughly to validate changes;./<=>?0@123ABC456DEFGHIJK7L <=>?@ABCDEFG    1234ӉE?@ABCD>=<FG     1234589:&'()*+,-;./<=>?0@123ABC456DEFGHIJK7LNoneSerialise a JSON value as a CBOR term in a generic but schema-dependent fashion. This is necessary because the JSON representation carries less information than we need in CBOR (e.g. it lacks a distinction between bytestrings and text).QConvert a JSON value into a CBOR term in a generic but schema-dependent fashion.MrEncode a record as a map from field names to values. Crucially, the fields are in ascending order by field name.NHEncode a union as a single-element map from the field name to the value.OcEncode an enumerated value as its name; we do not check that it actually belongs to the type here.When a JSON value has been deserialised from CBOR, the representation may need some modifications in order to match the result of C on a Haskell datatype. In particular, Aeson's representation of  does not round-trip (because  is encoded as  and  x as  xL), so CBOR uses a different representation (as an empty or 1-element list).PForce the unnecessarily lazy  representation.QRMNOSTUPVWQRMNOSTUPVWNoneT:Tool to generate a list of JSON round-trip tests of type [(X, Y)]( with the given name. This depends on jsonTool and quickCheckTool.:Tool to generate a list of CBOR round-trip tests of type [(X, Y)]( with the given name. This depends on cborTool and quickCheckTool.Z)Tool to generate a list of tests of type [(X, Y)]4 based on instantiating the first argument at type  A -> Bool for each type AZ in the API. The second argument is the name of the declaration that should be produced.[tFor an APINode, generate a (String, Property) pair giving the type name and an appropriate instance of the propertyBTool to generate a list of CBOR-to-JSON conversion tests of type [(X, Y)]. The first name must be the og being tested, and the second should be the name of the declaration to be produced. This depends on cborTool, jsonTool and quickCheckTool.BTool to generate a list of JSON-to-CBOR conversion tests of type [(X, Y)]. The first name must be the og being tested, and the second should be the name of the declaration to be produced. This depends on cborTool, jsonTool and quickCheckTool.*Tool to generate a list of tests that the K generic representation agrees with the type-specific JSON representation.*Tool to generate a list of tests that the K generic representation agrees with the type-specific CBOR representation.\oTool to generate a list of tests of properties that take the API and the type name as arguments, and return a ].QuickCheck property that a . decodes to an expected Haskell value, using `QuickCheck property that a . decodes to an expected Haskell value, using a with the given Y=QuickCheck property that Haskell values can be encoded with toJSON and decoded with ` to get the original valueEQuickCheck property that CBOR decoding is a left inverse for encodingQuickCheck property that toJSONq agrees with encoding to CBOR directly and then decoding using the schema-aware generic decoder. From this and  it follows that >fromJSONWithErrs . deserialiseJSONWithSchema . serialise == idQuickCheck property that direct encoding to CBOR agrees with conversion to JSON followed by the schema-aware generic encoder. From this and  it follows that 4deserialise . serialiseJSONWithSchema . toJSON == idZ[\  Z[\None/Generate the datatypes corresponding to an API.>Generate the datatypes corresponding to an API, allowing the  to be overriden.Apply a list of tools to an o], generating TH declarations. See the individual tool descriptions for details. Note that u must be called first, and some tools have dependencies, which must be included in the same or a preceding call to .Apply a list of tools to an o4, generating TH declarations. This form allows the  to be overridden.((None /023459:;<=?@ABDFIJKNOQRTu^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~g^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~`9 a9 'NoneNone+API description of the api-tools API itself None0I^      !"#$%&'()*+,-./0RSTUVWXYZ[\]^_`abcdefghijklm]      !"#$%&'()*+,-./0RSTUVWXYZ[\]^_`abcdefghijkl   !"   #$%&'()*+,-./0mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmlkjihgfedcba`_^]\[ZYXWVUTSR*      !"#$%&'()*+,-./0RSTUVWXYZ[\]^_`abcdefghijklm!None!";Take an API spec and generate a JSON description of the API"Generate an API spec from the JSON()*+,-./0123456789:;<=>?@ABCDEFGGHIJKLMNOPQRSTUVWXYZ[\]]^__`aabcdeffghhijkklmnnopqrstuuvwxyz{|}~      !"#$%&'()*+,-./0123 4 5 6 7 8 9 : ; < = > ? @ A B C D EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%&      !"#$%&'()*+,-./0*123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ I       P         V             \ \   k k   n n      q    u u ! " x # $ % & '   ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 :   ; < = > ? @ A B C D p o m l 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 { | } ~                                !!!!}( """"""                 ############################# # # # ### ###################### #!#"###$#%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#K#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#wxyz{|(}~%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&( ((lp((     ( !"#$$%&'()*+,-./01234566789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!!!!!!!!!!!!!!!!!!!!!!!!(api-tools-0.8.0.1-HS5qUSwuTsQLp2vicrYvZp Data.Binary.Serialise.CBOR.ExtraData.Binary.Serialise.CBOR.JSONData.API.UtilsData.API.TypesData.API.Tools.Combinators Data.API.THData.API.Tools.DatatypesData.API.Tools.LensData.API.Tools.SafeCopyData.API.Tools.DeepSeqData.API.Tools.EnumData.API.Tools.CBORData.API.Tools.ExampleData.API.Tools.QuickCheck Data.API.PPData.API.NormalFormData.API.Tools.TraversalData.API.Markdown Data.API.DocData.API.Doc.SubstData.API.Changes.TypesData.API.Error Data.API.JSONData.API.Tools.JSONData.API.ValueData.API.ChangesData.API.JSONToCBORData.API.Tools.JSONTestsData.API.ToolsData.API.ParseData.API.API.DSLData.API.API.Gen Data.API.APIData.API.TH.Compat Data.API.ScanData.API.Doc.TypesData.API.Doc.DirData.API.Doc.CallData.API.Tutorialbase Control.Monad<$!> encodeJSON decodeJSON cborToJson jsonToCbor$fSerialiseValueencodeListWithencodeMaybeWithencodeRecordFields encodeUnion decodeUniondecodeListWithdecodeMaybeWith MergeResult OnlyInLeftInBoth OnlyInRightmkUTCmkUTC'mkUTC_ parseUTC' parseUTC_?!?!? mergeMapsdiffMaps matchMaps$fEqMergeResult$fShowMergeResultBinary_Binary DefaultValue DefValList DefValMaybe DefValString DefValBool DefValInt DefValUtc BasicTypeBTstringBTbinaryBTboolBTintBTutcAPITypeTyListTyMaybeTyNameTyBasicTyJSON ConversionSpecEnumseAlts SpecUnionsuFields FieldTypeftType ftReadOnly ftDefault ftComment SpecRecordsrFieldsRegExre_textre_regexUTCRangeur_lour_hiIntRangeir_loir_hiFilterFtrStrgFtrIntgFtrUTC SpecNewtypesnTypesnFilterSpec SpNewtypeSpRecordSpUnionSpEnum SpSynonymPrefix MDComment FieldName _FieldNameTypeName _TypeNameAPINodeanName anCommentanPrefixanSpec anConvertThing ThCommentThNodeAPI inIntRange inUTCRangemkRegExdefaultValueAsJsValuebase64ToBinary$fArbitraryBinary$fArbitraryText$fFromJSONBinary$fToJSONBinary$fNFDataDefaultValue$fNFDataBasicType$fNFDataAPIType$fIsStringAPIType$fNFDataSpecEnum$fNFDataSpecUnion$fNFDataFieldType$fNFDataSpecRecord $fShowRegEx $fEqRegEx$fFromJSONRegEx $fToJSONRegEx $fNFDataRegEx$fNFDataUTCRange$fNFDataIntRange$fNFDataFilter$fNFDataSpecNewtype $fNFDataSpec$fNFDataAPINode $fNFDataThing $fEqTypeName $fOrdTypeName$fShowTypeName$fNFDataTypeName$fIsStringTypeName $fEqFieldName$fOrdFieldName$fShowFieldName$fNFDataFieldName$fIsStringFieldName $fEqIntRange$fShowIntRange $fEqUTCRange$fShowUTCRange $fEqFilter $fShowFilter $fEqSpecEnum$fShowSpecEnum $fEqBasicType$fShowBasicType $fEqAPIType $fShowAPIType $fEqSpecUnion$fShowSpecUnion$fEqSpecNewtype$fShowSpecNewtype$fEqDefaultValue$fShowDefaultValue $fEqFieldType$fShowFieldType$fEqSpecRecord$fShowSpecRecord$fEqSpec $fShowSpec $fEqAPINode $fShowAPINode $fEqThing $fShowThing $fShowBinary $fEqBinary $fOrdBinary$fNFDataBinary$fSerialiseBinary$fSafeCopyBinary$fFromJSONThing $fToJSONThing$fFromJSONAPINode$fToJSONAPINode$fFromJSONTypeName$fToJSONTypeName$fFromJSONFieldName$fToJSONFieldName$fFromJSONSpec $fToJSONSpec$fFromJSONAPIType$fToJSONAPIType$fFromJSONDefaultValue$fToJSONDefaultValue$fFromJSONSpecEnum$fToJSONSpecEnum$fFromJSONSpecUnion$fToJSONSpecUnion$fFromJSONSpecRecord$fToJSONSpecRecord$fFromJSONFieldType$fToJSONFieldType$fFromJSONSpecNewtype$fToJSONSpecNewtype$fFromJSONFilter$fToJSONFilter$fFromJSONIntRange$fToJSONIntRange$fFromJSONUTCRange$fToJSONUTCRange$fFromJSONBasicType$fToJSONBasicType$fLiftDefaultValue$fLiftBasicType $fLiftAPIType$fLiftSpecEnum$fLiftSpecUnion$fLiftFieldType$fLiftSpecRecord $fLiftRegEx$fLiftUTCRange$fLiftIntRange $fLiftFilter$fLiftSpecNewtype $fLiftSpec$fLiftFieldName$fLiftTypeName $fLiftAPINode $fLiftThing $fFromJSONCI $fToJSONCI APINodeToolAPIToolToolrunTool ToolSettingswarnOnOmittedInstancenewtypeSmartConstructorsdefaultToolSettings simpleToolmkTool contramapToolreadToolsubTools apiNodeToolapiDataTypeTool apiSpecTool $fMonoidTool applicativeEoptionalInstanceDfunSigDsimpleD simpleSigD mkNameText fieldNameE fieldNameVarE typeNameE datatypesTooldatatypesTool'defaultDerivedClassestype_nm rep_type_nmnodeTnodeRepTnodeConEnodeNewtypeConE nodeFieldE nodeFieldP nodeAltConE nodeAltConPnewtypeProjectionElensToolbinary safeCopyTool deepSeqToolenumTool text_enum_nm map_enum_nmcborToolExampleexample samplesTool exampleTool$fExampleUTCTime$fExampleValue$fExampleBinary $fExampleText $fExampleBool $fExampleInt $fExample[]$fExampleMaybequickCheckTool$fArbitraryUTCTimePPLinesppLinesPPpp inFrontOfindent $fPPLines(,) $fPPLines[]$fPPDefaultValue $fPPBasicType $fPPAPIType $fPPFieldName $fPPTypeName$fPPLinesValue$fPPText$fPPSet $fPPVersion$fPP[] NormEnumType NormUnionTypeNormRecordType NormTypeDecl NRecordType NUnionType NEnumType NTypeSynonymNNewtypeNormAPI apiNormalFormdeclNFtypeDeclsFreeVarstypeDeclFreeVars typeFreeVarstypeDeclaredInApi typeUsedInApitypeUsedInTransitiveDeptransitiveDepstransitiveReverseDeps typeIsValid declIsValid apiInvariant substTypeDecl substTyperenameTypeUses$fPPLinesNormTypeDecl$fNFDataNormTypeDecl$fEqNormTypeDecl$fShowNormTypeDecl traversalToolMarkdownMethodsMDMmdmSummaryPostfixmdmLinkmdmPpmdmFieldDefaultdefaultMarkdownMethodsmarkdownthingDocInfodoc_info_call_urldoc_info_type_urlBody EmptyBodyJSONBody OtherBodySample sample_status sample_typesample_responseViewview_id view_typeview_doc view_paramsParam param_name param_expl param_desc param_typeparam_requiredHeader header_name header_expl header_desc header_typeheader_requiredCallcall_http_method call_pathcall_descriptioncall_auth_required call_headers call_body call_params call_views call_samples StatusCode HTTPMethodURLrenderBodyType renderAPITypemk_linkDictsubstprepmkDictextDictdirHtmlcallHtmlAPITableChange APIChange ValidateData UpdateTypePos UpdateList UpdateMaybe UpdateNamed UpdateDeclPos UpdateHere UpdateRecord UpdateUnion UpdateType VersionExtraRelease DevVersion MigrationTag ChAddType ChDeleteType ChRenameType ChAddField ChDeleteField ChRenameField ChChangeField ChAddUnionAltChDeleteUnionAltChRenameUnionAlt ChAddEnumValChDeleteEnumValChRenameEnumVal ChCustomType ChCustomAll APIChangelog ChangesUpTo ChangesStartAPIWithChangelogshowVersionExtra$fPPLinesAPITableChange$fPPVersionExtra$fPPLinesAPIChange $fEqAPIChange$fShowAPIChange$fEqVersionExtra$fOrdVersionExtra$fShowVersionExtra$fEqAPIChangelog$fShowAPIChangelog$fEqUpdateTypePos$fShowUpdateTypePos$fEqUpdateDeclPos$fShowUpdateDeclPos$fEqAPITableChange$fShowAPITableChangeMigrateWarningMigrateFailureValidateFailure ValueErrorTypeKindTKRecordTKUnionTKEnum TKNewtype TKTypeSynonym ApplyFailure TypeExistsTypeDoesNotExist TypeWrongKind TypeInUse TypeMalformed DeclMalformed FieldExistsFieldDoesNotExistFieldBadDefaultValueDefaultMissingTableChangeErrorafExistingType afMissingType afTypeNameafExpectedKindafTypeafMissingTypesafDecl afTypeKindafExistingFieldafMissingField afFieldName afFieldType afBadDefaultafCustomMessageValidateWarningChangelogOutOfOrderCannotDowngrade ApiInvalidChangelogEntryInvalidChangelogIncompletevfLaterVersionvfEarlierVersion vfFromVersion vfToVersionvfInvalidVersionvfMissingDeclarationsvfSuccessfullyAppliedvfFailedToApplyvfApplyFailurevfChangelogVersionvfTargetVersion vfDifferences JSONErrorCustomMigrationError InvalidAPIStepInFieldInElemPositionFormatExpected FmtBinaryFmtUTCFmtOtherExpectedExpArrayExpBoolExpInt ExpObject ExpString JSONWarning BadFormat MissingField MissingAltUnexpectedFieldUnexpectedEnumVal IntRangeError UTCRangeError RegexError SyntaxError expectedArray expectedBool expectedIntexpectedObjectexpectedString badFormatprettyJSONErrorinField prettyStepprettyJSONErrorPositionsprettyMigrateFailureprettyValidateFailureprettyValueErrorprettyValueErrorPosition$fPPLinesValueError$fPPLinesApplyFailure$fPPLinesValidateFailure$fPPLinesMigrateFailure $fPPTypeKind $fPPLinesStep $fEqExpected$fShowExpected$fEqFormatExpected$fShowFormatExpected $fEqJSONError$fShowJSONError$fEqStep $fShowStep$fShowValidateWarning $fEqTypeKind$fShowTypeKind$fEqApplyFailure$fShowApplyFailure$fEqValidateFailure$fShowValidateFailure$fEqValueError$fShowValueError$fEqMigrateFailure$fShowMigrateFailure$fFromJSONJSONError$fToJSONJSONError$fFromJSONExpected$fToJSONExpected$fFromJSONFormatExpected$fToJSONFormatExpected$fFromJSONStep $fToJSONStep$fSafeCopyStepFromJSONWithErrsparseJSONWithErrs ParseFlags useDefaultsenforceReadOnlyFieldsenforceFiltersParserWithErrsdefaultParseFlagsrunParserWithErrsTopfromJSONWithErrsfromJSONWithErrs'fromJSONWithErrs''decodeWithErrsdecodeWithErrs'parseJSONDefaultwithParseFlagsfailWithwithInt withIntRange withBinarywithBoolwithText withRegExwithUTC withUTCRange withVersion withFieldwithDefaultField.:..:: withUnion$fFromJSONWithErrsVersion$fFromJSONWithErrsUTCTime$fFromJSONWithErrsText$fFromJSONWithErrsBinary$fFromJSONWithErrsBool$fFromJSONWithErrsInteger$fFromJSONWithErrsInt$fFromJSONWithErrs[]$fFromJSONWithErrsMaybe$fFromJSONWithErrs()$fFromJSONWithErrsValue$fMonadParserWithErrs$fAlternativeParserWithErrs$fApplicativeParserWithErrs$fFunctorParserWithErrsjsonTool jsonTool'toJsonNodeToolfromJsonNodeToolfromJsonWithErrsNodeToolField fieldName fieldValueRecordValueStringUTCTimeBytesBoolIntListMaybeUnionEnumJSONfromDefaultValuefromJSON parseJSONencodedecodematchesNormAPI expectRecord expectEnum expectUnion expectList expectMaybe lookupType arbitraryarbitraryOfTypearbitraryJSONValueprop_jsonRoundTripprop_jsonGenericprop_cborRoundTripprop_cborGeneric recordToMap mapToRecord insertField deleteField renameField findField joinRecords $fToJSONValue $fNFDataField $fNFDataValue $fEqField $fShowField $fEqValue $fShowValue DataChecksNoChecksCheckStartAndEnd CheckCustomCheckAllCustomMigrationsdatabaseMigrationdatabaseMigrationSchema typeMigrationtypeMigrationSchemafieldMigrationmigrateDataDumpmigrateDataDump'mkRecordMigrationmkRecordMigration'mkRecordMigrationSchema noDataChangesnoSchemaChangeschangelogStartVersionchangelogVersionvalidateChangesdataMatchesAPIgenerateMigrationKinds$fEqDataChecks$fOrdDataChecksserialiseJSONWithSchemajsonToCBORWithSchemadeserialiseJSONWithSchemapostprocessJSON jsonTestsTool cborTestsToolcborToJSONTestsTooljsonToCBORTestsTooljsonGenericValueTestsToolcborGenericValueTestsToolprop_decodesToprop_decodesTo'prop_resultsMatchRoundtripprop_cborRoundtripprop_cborToJSONprop_jsonToCBORgenerate generateWithgenerateAPIToolsgenerateAPIToolsWithparseAPIparseAPIWithChangelogapiapiWithChangelogapiAPIDV_listDV_maybe DV_string DV_boolean DV_integerDV_utc BT_string BT_binary BT_boolean BT_integerBT_utcTypeRef_TypeRefTY_listTY_maybeTY_refTY_basicTY_json_fd_name_fd_type _fd_readonly _fd_default _fd_comment _cv_injection_cv_projection_ur_lo_ur_hi_ir_lo_ir_hiRegularExpression_RegularExpression FT_string FT_integerFT_utc_sn_type _sn_filter SP_newtype SP_recordSP_unionSP_enum SP_synonym_an_name _an_comment _an_prefix_an_spec _an_convertAPISpec$fIsStringRegularExpression$fShowRegularExpression$fEqRegularExpression$fOrdRegularExpression$fShowConversion$fEqConversion$fIsStringTypeRef $fShowTypeRef $fEqTypeRef $fOrdTypeRef$fOrdBasicType$fBoundedBasicType$fEnumBasicType_text_BasicType_map_BasicType an_comment an_convertan_name an_prefixan_spec sn_filtersn_typeregularExpression cv_injection cv_projection fd_comment fd_defaultfd_name fd_readonlyfd_typetypeRef apiAPISamplesapiAPITestsJSONapiAPITestsCBORapiAPITestsCBORToJSONapiAPITestsJSONToCBOR$fExampleDefaultValue$fExampleBasicType$fExampleTypeRef$fExampleAPIType$fExampleField$fExampleConversion$fExampleUTCRange$fExampleIntRange$fExampleRegularExpression$fExampleFilter$fExampleSpecNewtype $fExampleSpec$fExampleAPINode$fSafeCopyDefaultValue$fSafeCopyBasicType$fSafeCopyTypeRef$fSafeCopyAPIType$fSafeCopyField$fSafeCopyConversion$fSafeCopyUTCRange$fSafeCopyIntRange$fSafeCopyRegularExpression$fSafeCopyFilter$fSafeCopySpecNewtype$fSafeCopySpec$fSafeCopyAPINode$fArbitraryDefaultValue$fArbitraryBasicType$fArbitraryTypeRef$fArbitraryAPIType$fArbitraryField$fArbitraryConversion$fArbitraryUTCRange$fArbitraryIntRange$fArbitraryRegularExpression$fArbitraryFilter$fArbitrarySpecNewtype$fArbitrarySpec$fArbitraryAPINode$fNFDataTypeRef$fNFDataConversion$fNFDataRegularExpression$fSerialiseDefaultValue$fSerialiseBasicType$fSerialiseTypeRef$fSerialiseAPIType$fSerialiseField$fSerialiseConversion$fSerialiseUTCRange$fSerialiseIntRange$fSerialiseRegularExpression$fSerialiseFilter$fSerialiseSpecNewtype$fSerialiseSpec$fSerialiseAPINode$fFromJSONWithErrsDefaultValue$fFromJSONWithErrsBasicType$fFromJSONWithErrsTypeRef$fFromJSONTypeRef$fToJSONTypeRef$fFromJSONWithErrsAPIType$fFromJSONWithErrsField$fFromJSONField $fToJSONField$fFromJSONWithErrsConversion$fFromJSONConversion$fToJSONConversion$fFromJSONWithErrsUTCRange$fFromJSONWithErrsIntRange#$fFromJSONWithErrsRegularExpression$fFromJSONRegularExpression$fToJSONRegularExpression$fFromJSONWithErrsFilter$fFromJSONWithErrsSpecNewtype$fFromJSONWithErrsSpec$fFromJSONWithErrsAPINode extractAPI convertAPI unconvertAPI$fFromJSONWithErrsThingcborToJsonString base64urlbase64base16 utcFormat utcFormats$aeson-1.2.2.0-FMZP6GLGxlE7ZNTC2Q74mXData.Aeson.Types.InternalData.Aeson.Types.ToJSONtoJSONData.Aeson.Types.FromJSON liftPrefixliftUTCliftMaybeUTCTimeGHC.BaseMonoid StrictnessmkDataD mkInstanceD mkNewtypeD annIsStrict annNotStrictgen_sy gen_sn_dt gen_sr_dt gen_su_dt gen_se_dtnewtype_prj_nmnewtype_con_nmnewtype_smart_con_nm pref_field_nm pref_con_nmmk_type basic_typederive_leaf_nmsderive_node_nms rep_type_s'safecopy-0.9.3.3-3xa0Ox8YjdCE7V9mGxqL0JData.SafeCopy.SafeCopySafeCopydeepseq-1.4.2.0Control.DeepSeqNFDatagen_sngen_srgen_sugen_se gen_se_tx gen_se_mp genTextMap(serialise-0.1.0.0-IcpazgjKb2w3def4VCOpH2Codec.Serialise.Class Serialise gen_sn_to gen_sr_to gen_su_to gen_se_to cborStrMap_pgen_pr'QuickCheck-2.9.2-LUnRjwrWhwjHswl9yQmDJjTest.QuickCheck.Arbitrary gen_sn_ex Arbitrary gen_sr_ex gen_su_ex gen_se_ex gen_sn_abarbitraryBoundedIntegral gen_sr_ab gen_su_ab gen_se_abarbitraryIntRangeghc-prim GHC.TypesarbitraryUTCRange time-1.6.0.1Data.Time.Clock.UTC utf8EncodeAlexAcc AlexAccNone AlexAccSkip AlexLastAccAlexNone AlexLastSkip AlexReturnAlexEOF AlexErrorAlexSkip AlexTokenAlexAddrAlexA#TokenSemiBarBInaryBraKetColColColonCommaEqualsLtEqGtEqBooleanIntegerUTCQueryJsonVersionWithBasicChangesAddedRemovedRenamedChangedDefault Alternative MigrationToNOTHINGTRUEFALSEReadonlyUTCTIMECommentTypeIdenVarIdenIntgStrgERRORPTokenAlexPosnAlexPn AlexInputByteignorePendingBytesalexInputPrevChar alexGetByte alexStartPosalexMovealexScanTokens alex_tab_size alex_base alex_table alex_check alex_deflt alex_acceptkeywordsutc_ line_comment block_commentstrip_qsmunch_wssimpleintgstringchopmkscantest alex_action_3 alex_action_4 alex_action_5 alex_action_6 alex_action_7 alex_action_8 alex_action_9alex_action_10alex_action_11alex_action_12alex_action_13alex_action_14alex_action_15alex_action_16alex_action_17alex_action_18alex_action_19alex_action_20alex_action_21alex_action_22alex_action_23alex_action_24alex_action_25alex_action_26alex_action_27alex_action_28alex_action_29alex_action_30alex_action_31alex_action_32alex_action_33alex_action_34alex_action_35alex_action_36alex_action_37alex_action_38alex_action_39alex_action_40alex_action_41alex_action_42alex_action_43alex_action_44alex_action_45alex_action_46alex_action_47alex_action_48alexIndexInt16OffAddralexIndexInt32OffAddr quickIndexalexScan alexScanUser alex_scan_tkn$fFunctorAlexLastAcctransitiveClosure traversalName traversalType traverser traverser'NothingtraversalRecordtraversalUnionnodeheaderbodyntyperecordunion_enum_synonymmk_md_record_tablemk_md_union_table cleanComment summary_lines default_valuetype_md basic_type_md type_name_md prefix_md comment_mdblockversionljustsubst_re aggregate resourceHtml resource_dict call_dictcontainer_openresource_headingul_opencallul_close headersHtml paramsHtml paramsRowsbodyHtml viewsHtml samplesHtmlcall_dict_headercall_dict_paramcall_dict_sample headers_headheader_content headers_foot no_params params_head parameter_row params_foot body_sample views_head view_content views_footview_detail_headview_detail_footsample_headingsample GHC.ClassesOrd Data.Version sortDiffs ppATypeKind ppMemberWordppDiffsmergeResultFreeVarsppDiff ppDiffFields*attoparsec-0.13.2.0-7ZfZrHd6gcN5AtIVXYj8EK#Data.Attoparsec.ByteString.InternalParserMonad ApplicativemodifyTopError withFilterwithStrictFieldrunParserWithErrswarning stepInsidewithNumtreatAsMissingToJSONFromJSON gen_FromJSON gen_sn_fm gen_sr_fm gen_su_fm gen_se_fmgen_inmkInt jsonStrMap_p json_string_pcontainers-0.5.7.1 Data.Map.BaseMapNullJust lookupTyName lookupSet lookupMapfromDefaultValueBasicparseJSONBasic parseJSONDecl decodeBasic decodeDeclmatchesNormAPIBasicmatchesNormAPIDeclarbitraryOfBasicTypearbitraryOfDecl validateAfterviewChangelogReverse viewChangelogisChangelogOrdered changelogTags changeTags findUpdatePosvalidateChanges'applyAPIChangesToAPI doChangeAPIapplyChangesToDatabase updateDeclAt updateTypeAtapplyChangeToData updateDeclAt' updateTypeAt'applyChangeToData'defaultValueForTypeDecodeCustomMigrationsTaggedreadCustomMigrations selectChangesapplyAPIChangeToAPIexpectRecordTypeexpectUnionTypeexpectEnumTypeapplyChangeToDatabase liftMigrationapplyChangesToDatabase'applyChangeToDatabase' withObjectwithObjectFieldwithObjectMatchingFieldswithObjectMatchingUnionwithArrayElems withMaybe withStringcompatibleDefaultValuedataMatchesNormAPIjsonToCBORRecordjsonToCBORUnionjsonToCBOREnum forceUTCTimejsonToCBORTypeNamejsonToCBORTypejsonToCBORBasicpostprocessJSONTypeNamepostprocessJSONTypepostprocessJSONRecordpostprocessJSONUnionTest.QuickCheck.PropertyProperty testsTool generatePropschemaTestsToolResult HappyAddrHappyA#HappyStk Happy_IntList HappyCons EnumChangeEnChAdd EnChDelete EnChRename UnionChangeUnChAdd UnChDelete UnChRename FieldChangeFldChAdd FldChDelete FldChRename FldChChangeParseMHappyAny HappyAbsSynhappyIn5 happyOut5happyIn6 happyOut6happyIn7 happyOut7happyIn8 happyOut8happyIn9 happyOut9 happyIn10 happyOut10 happyIn11 happyOut11 happyIn12 happyOut12 happyIn13 happyOut13 happyIn14 happyOut14 happyIn15 happyOut15 happyIn16 happyOut16 happyIn17 happyOut17 happyIn18 happyOut18 happyIn19 happyOut19 happyIn20 happyOut20 happyIn21 happyOut21 happyIn22 happyOut22 happyIn23 happyOut23 happyIn24 happyOut24 happyIn25 happyOut25 happyIn26 happyOut26 happyIn27 happyOut27 happyIn28 happyOut28 happyIn29 happyOut29 happyIn30 happyOut30 happyIn31 happyOut31 happyIn32 happyOut32 happyIn33 happyOut33 happyIn34 happyOut34 happyIn35 happyOut35 happyIn36 happyOut36 happyIn37 happyOut37 happyIn38 happyOut38 happyIn39 happyOut39 happyIn40 happyOut40 happyIn41 happyOut41 happyIn42 happyOut42 happyIn43 happyOut43 happyIn44 happyOut44 happyIn45 happyOut45 happyIn46 happyOut46 happyIn47 happyOut47 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nonterms happyReduce_2happyReduction_2 happyReduce_3happyReduction_3 happyReduce_4happyReduction_4 happyReduce_5happyReduction_5 happyReduce_6happyReduction_6 happyReduce_7happyReduction_7 happyReduce_8happyReduction_8 happyReduce_9happyReduction_9happyReduce_10happyReduction_10happyReduce_11happyReduction_11happyReduce_12happyReduction_12happyReduce_13happyReduction_13happyReduce_14happyReduction_14happyReduce_15happyReduction_15happyReduce_16happyReduction_16happyReduce_17happyReduction_17happyReduce_18happyReduction_18happyReduce_19happyReduction_19happyReduce_20happyReduction_20happyReduce_21happyReduction_21happyReduce_22happyReduction_22happyReduce_23happyReduction_23happyReduce_24happyReduction_24happyReduce_25happyReduction_25happyReduce_26happyReduction_26happyReduce_27happyReduction_27happyReduce_28happyReduction_28happyReduce_29happyReduction_29happyReduce_30happyReduction_30happyReduce_31happyReduction_31happyReduce_32happyReduction_32happyReduce_33happyReduction_33happyReduce_34happyReduction_34happyReduce_35happyReduction_35happyReduce_36happyReduction_36happyReduce_37happyReduction_37happyReduce_38happyReduction_38happyReduce_39happyReduction_39happyReduce_40happyReduction_40happyReduce_41happyReduction_41happyReduce_42happyReduction_42happyReduce_43happyReduction_43happyReduce_44happyReduction_44happyReduce_45happyReduction_45happyReduce_46happyReduction_46happyReduce_47happyReduction_47happyReduce_48happyReduction_48happyReduce_49happyReduction_49happyReduce_50happyReduction_50happyReduce_51happyReduction_51happyReduce_52happyReduction_52happyReduce_53happyReduction_53happyReduce_54happyReduction_54happyReduce_55happyReduction_55happyReduce_56happyReduction_56happyReduce_57happyReduction_57happyReduce_58happyReduction_58happyReduce_59happyReduction_59happyReduce_60happyReduction_60happyReduce_61happyReduction_61happyReduce_62happyReduction_62happyReduce_63happyReduction_63happyReduce_64happyReduction_64happyReduce_65happyReduction_65happyReduce_66happyReduction_66happyReduce_67happyReduction_67happyReduce_68happyReduction_68happyReduce_69happyReduction_69happyReduce_70happyReduction_70happyReduce_71happyReduction_71happyReduce_72happyReduction_72happyReduce_73happyReduction_73happyReduce_74happyReduction_74happyReduce_75happyReduction_75happyReduce_76happyReduction_76happyReduce_77happyReduction_77happyReduce_78happyReduction_78happyReduce_79happyReduction_79happyReduce_80happyReduction_80happyReduce_81happyReduction_81happyReduce_82happyReduction_82happyReduce_83happyReduction_83happyReduce_84happyReduction_84happyReduce_85happyReduction_85happyReduce_86happyReduction_86happyReduce_87happyReduction_87happyReduce_88happyReduction_88happyReduce_89happyReduction_89happyReduce_90happyReduction_90happyReduce_91happyReduction_91happyReduce_92happyReduction_92happyReduce_93happyReduction_93happyReduce_94happyReduction_94happyReduce_95happyReduction_95happyReduce_96happyReduction_96happyReduce_97happyReduction_97happyReduce_98happyReduction_98happyReduce_99happyReduction_99happyReduce_100happyReduction_100happyReduce_101happyReduction_101happyReduce_102happyReduction_102happyReduce_103happyReduction_103happyReduce_104happyReduction_104happyReduce_105happyReduction_105happyReduce_106happyReduction_106happyReduce_107happyReduction_107 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError'parseparse_with_changeloghappySeq happyErrorwrapfldChangeToAPIChangeunionChangeToAPIChangeenumChangeToAPIChangeparseVerparseVersionExtralocated happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeqconvert convert_specconvert_conversionconvert_specntconvert_filterconvert_fields convert_union convert_alts convert_type convert_ref convert_basicconvert_default unconvertunconvert_specunconvert_conversionunconvert_specntunconvert_filterunconvert_fieldsunconvert_unionunconvert_altsunconvert_type unconvert_refunconvert_basicunconvert_default