52       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk l m n o p q r s t u v w x y z { | } ~                        None  None The "oh noes!" operator.         NoneB! EBinary data is represented in JSON format as a base64-encoded stringA default value for a field;the basic JSON types (N.B., no floating point numbers, yet)a JSON UTC stringa JSON integral number a JSON boola base-64-encoded byte stringa JSON UTF-8 stringHType is either a list, Maybe, a named element of the API or a basic typea generic JSON valuea JSON string, int, bool etc..the referenced type must be defined by the API Maybe elements are types!list elements are types#(SpecEnum is your classic enumerated type&%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.BESpecNewtype elements are isomorphisms of string, inetgers or booleansFrtype/element specs are either simple type isomorphisms of basic JSON types, records, unions or enumerated typesLia 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 APIM,Markdown comments are represented by stringsNFieldName 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)Q6TypeName must contain a valid Haskell type constructorT/Specifies an individual element/type of the APIVname of Haskell typeW#comment describing type in MarkdownX!distinct short prefix (see below)Ythe type specificationZoptional conversion functions^kan API spec is made up of a list of type/element specs, each specifying a Haskell type and JSON wrappersb$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 stringx  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab !"#$%&'()*+,-./W  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abW^[]\TUVWXYZQRSNOPMLFKJIHGBCDE/01)*+,-.&'(#$%"! >A@?:;<=67892345 ba_`;  ! "#$%&'()*+,-./0123456789:;<=>A@?BCDEFKJIHGLMNOPQRSTUVWXYZ[]\^_`ab !"#$%&'()*+,-./None-1 cLike 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.dYParse 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.e2Options to modify the behaviour of the JSON parserf`If true, default values from the schema will be used when a field is missing from the JSON datagWIf true, fields in the schema marked read-only will be overwritten with default valuesh_If true, parse errors will be generated when invalid values are supplied for filtered newtypesiLike 0_, but keeping track of locations within the JSON structure and able to report multiple errors. Careful! The 1" instance does not agree with the 28 instance in all circumstances, and you should use the 2* instance where possible. In particular: pf <*> ps# returns errors from both arguments pf `ap` ps returns errors from pf onlyjOEach step may be into a field of an object, or a specific element of an array.mxA position inside a JSON value is a list of steps, ordered innermost first (so going inside an object prepends a step).n#Special format expected of a stringr^JSON type expected at a particular position, when a value of a different type was encounteredx=At present, we do not distinguish between errors and warningsy9Represents an error that can be encountered while parsing0Human-readable description of a JSON parse error9Human-readable description of a single step in a positionKHuman-readable presentation of a list of parse errors with their positions=Use this as a basis for overriding individual fields of the e4 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 successfulRun 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 d. as it will not pass on the current position.wRun the JSON parser on a value to produce a result or a list of errors with their positions. This version allows the e to be specified.wRun the JSON parser on a value to produce a result or a list of errors with their positions. This version allows the eE to be specified, and produces warnings even if the parse succeeded. Decode a  ByteString and run the JSON parser Decode a  ByteString( and run the JSON parser, allowing the e to be specified!Suitable as an implementation of  parseJSON that uses the c9 instance (provided said instance was not defined using fromJSON!).3dIf this parser returns any errors at the current position, modify them using the supplied function.4If the conditional is false, fail with an error (if filters are not being enforced) or report a warning and continue (if they are).=Look up the value of a field, treating missing fields as null_Look up the value of a field, which may be read-only or use a default value (depending on the e).57Look up the value of a field, failing on missing fields;Parse the value of a field, treating missing fields as null5Parse the value of a field, failing on missing fieldsMatch an inhabitant of a disjoint union, which should be an object with a single field, and call the continuation corresponding to the field name._cde6fghi78jklmnopqrstuvwxyz{|}~9:34;<5=>?@ABCDEFGHIJKLMNOBcdefghijklmnopqrstuvwxyz{|}~By~}|{zxrwvutsnqpomjlkiefghcdDcde6fghi78jlkmnqporwvutsxy ~}|{z9:34;<5=>?@ABCDEFGHIJKLMNONone24PQRSTUVWXYZ[\PQRSTUVWXYZ[\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 T=. Equality of the normal form indicates equivalence of APIs.We track all types.TThe 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.ECompute the normal form of an API, discarding extraneous information.5Compute the normal form of a single type declaration.)Find the set of type names used in an API0Find the set of type names used in a declaration*Find the set of type names used in an type&Check if a type is declared in the API+Check if a type is used anywhere in the APIJCheck if the first type's transitive dependencies include the second type5Compute the transitive dependencies of a set of typesFCompute the set of types that depend (transitively) on the given types]Compute the transitive closure of a relation. Relations are represented as functions that takes a set of elements to the set of related elements.rTest that all the free type names in a type are declared in the API. If not, return the set of undeclared types.yTest that all the types used in a type declaration are declared in the API. If not, return the set of undeclared types.cTest that all the types used in the API are declared. If not, return the set of undeclared types.0Substitute types for type names in a declaration)Substitute types for type names in a type6Rename the first type to the second throughout the API]^]^None?8Errors that can be discovered when migrating data valuesAn API change was invalid'Error generated during custom migrationData doesn't match schema2Errors that may occur applying a single API changecustom error in tableChangefor adding a field to a tableGfor adding a field, must be a default value compatible with the type for deleting or renaming a fieldfor adding or renaming a field"decl refers to a non-existent type"type refers to a non-existent type.cannot delete/modify types that are still usede.g. it's not a record typefor deleting or renaming a typefor adding or renaming type9Errors that may be discovered when validating a changelogTchangelog is incomplete (ie all entries apply ok but result isn't the target api)changelog entry does not apply'an API uses types that are not declared7forbid migrating from one version to an earlier version5the changelog must be in descending order of versions_5Request to validate the dataset against the given API`?The pair of an APIChange and the positions in which to apply ita5Represents the positions in a type to apply an updateb<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 releaseXWhen to validate the data against the schema (each level implies the preceding levels):After every changeAfter custom migrations!At start and end of the migration Not at all}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 c.The db, ty and fldL parameters should be instantiated with the enumeration types generated by 6U, which correspond to the exact set of custom migration tags used in the changelog.aWithin the changelog, custom migrations are represented as strings, so we have less type-safety."A single change within a changelog An 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 d e instance).!The initial version"9The changes from the previous version up to this version.(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 values*KLift a schema change on record types to work on arbitrary type declarations+Use for  ,   or 7 to indicate that changes to the data are not required,Use for   or  3 to indicate that the schema should not be changedf1Whether to validate the dataset after this change.%The earliest version in the changelog/#The latest version in the changeloggKChangelog in order starting from oldest version up to newest. Entries are  (from, to, changes-oldest-first).hpChangelog in order as written, with latest version at the beginning, going back to older versions. Entries are  (to, from, changes-latest-first).iWIs the changelog in the correct order? If not, return a pair of out-of-order versions.jmSets of custom migration tags in the changelog for whole-database, single-record and single-field migrationsk0Sets of custom migration tags in a single changel^Given a type to be modified, find the positions in which each type in the API must be updated0XCheck that a changelog adequately describes how to migrate from one version to another.mInternal version of 0@, which works on unsafe migration tags and returns the list of ns to apply to the dataset.oApply 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.pApply the API changeq5This 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.r>Apply an update at the given position in a declaration's values6Apply an upate at the given position in a type's valuet`This actually applies the change to the data value, assuming it is already in the correct placeu`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.1Check that a dataset matches an API, which is necessary for succesful migration. The name of the dataset's type must be specified.6jGenerate enumeration datatypes corresponding to the custom migrations used in an API migration changelog.vwn_`axyzb{|}~      !"#$%&'(Starting 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)*+,f-./ghijkl0Starting schema and versionEnding schema and versionChangelog to be validatedCustom migration functionsName of the dataset's type"How thoroughly to validate changesmStarting schema and versionEnding schema and versionChangelog to be validatedCustom migration functionsName of the dataset's type"How thoroughly to validate changesopqrstu123456~      !"#$%&'()*+,-./0123456(01 "!#-./     )*+,6%'&$2345Vv"wn`_azyxb~}|{      "!#$%'&()*+,f-./ghijkl0mopqrstu123456None-&7PRecord of arguments that must be supplied to generate HTML documentation for a X94URL for individual call documentation from the index:$URL for documentation of an API type; Type for ?4 response body, parameterised by possible JSON types<A non-empty, non-JSON response=!A JSON response of the given type>An empty response?Example response data from a XA*HTTP status code for this example responseBType of example responseCContent of response, or c for empty responseD<Documents a specific view of the result data available in a XF View nameGType of result data returnedHFree-form text descriptionI3Query parameters that may be supplied for this viewJ<Documents a URL query parameter that may be included with a XLParameter nameMExample value for parameterNFree-form text descriptionOType of data in the parameterP%Is including the parameter mandatory?Q2Documents a HTTP header that may be supplied to a XS Header nameTExample value for headerUFree-form text descriptionVType of data in headerW3Is including the header with the request mandatory?XADocuments a single method call on a resource in a web applicationZHTTP method being documented[!Relative URL path of the resource\Free-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 calla"Available views of the result databExample responses2789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh2789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh 789:;>=<?@ABCDEFGHIJKLMNOPQRSTUVWX YZ[\]^_`abcdefghNonei"Generate a web page documenting a XiiiNonej(Generate a web page documenting all the Xs in a web application jj jNone4789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij4ijXYZ[\]^_`abQRSTUVWJKLMNOPDEFGHI?@ABC;>=<789:edcgfh Noner:Create human-readable API documentation in Markdown formats8Document a single API comment or node in Markdown formatklmnopqrs klmnopqrs rklmnopqsklmnopqrsNone;BEncode a Haskell String to a list of Word8 values, in UTF8 format.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk1     3X,      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk None *+-./02345689:;=?BCDGHJKMulmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~tuvwtuvwtuvwglmnopqrutsvyxwz~}|{      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~tuvwn o  NonezA z 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 exists~iRename 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 settingsz 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.xyz{|}~xyz{|}~z{yx{|}~}~xyz{|}~NoneConstruct an idiomatic expression (an expression in an Applicative context), i.e. app 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 NoneDTool to generate datatypes and type synonyms corresponding to an API"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)5Name of the type corresponding to the API node, e.g. JobIdWName 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 node4The 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 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   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_FrameRateNone1bThe 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 FooNoneTool to generate  and c# 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 c# instances for types generated by . This depends on . Note that generated  and cH instances will always agree on the decoding of a value, but that the c2 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 c instance.Tool to generate c instance for an API node Generate  instances like this: 8instance FromJSON T where parseJSON = parseJSONDefault          NoneM)Tool to generate a list of tests of type [(, )]( with the given name. This depends on jsonTool and quickCheckTool.For an APINode, generate a (String, Property) pair giving the type name and an appropriate instance of the prop_resultsMatchRoundtrip propertyQuickCheck property that a Value. decodes to an expected Haskell value, using QuickCheck property that a Value. decodes to an expected Haskell value, using  with the given e=QuickCheck property that Haskell values can be encoded with toJSON and decoded with  to get the original valueNone2Tool to make lenses for fields in generated types.NoneTool 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. "$ "$NoneTool to derive %W instances for generated types. At present, this derives only base version instances.&&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 ^], 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 ^4, generating TH declarations. This form allows the | to be overridden.|}~|}~}~NoneHMbBuild 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 :, otherwise the generated code will lead to scope errors.'traversalName x tn- is the name of the function that traverses x values inside tn(traversalType x an- is the type of the function that traverses x values inside an)>Construct a traversal of the X substructures of the given type*KConstruct a traversal of the X substructures of the given type, or return c* 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 b'()*+,'()*+,NoneNone+API description of the api-tools API itselfNone+B[Z'None;Take an API spec and generate a JSON description of the API-"Generate an API spec from the JSON./0123456789:;<=>?@ABCDE-./0123456789:;<=>?@ABCDE-F !"#$%&'()*++,-./0123456789:;<=>?@AABCCDEEFGHIJJKLLMNOOPQRRSTUVWXYYZ[\]^_`abcddeffghhijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEEFGHIJKLLMNOPPQRSTUUVWXYZ[[\]^_`aabcdefghijklmnopqr s t u v w x y z { | } ~                               -4:@@OORRUYY\hhTSQP      !"#$%&'()'*+,-.x|/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV WX'YZ[\]'^_`abcdefghijklmnopqrstuvwxyz{|}~q                     _      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\] ^ _ ` ` a b c d e f g h i j k l m n o p q r 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:;< api-tools-0.5Data.API.Doc.SubstData.API.UtilsData.API.Types Data.API.JSON Data.API.PPData.API.NormalFormData.API.Changes Data.API.DocData.API.MarkdownData.API.ParseData.API.Tools.CombinatorsData.API.Tools.DatatypesData.API.Tools.EnumData.API.Tools.ExampleData.API.Tools.JSONData.API.Tools.JSONTestsData.API.Tools.LensData.API.Tools.QuickCheckData.API.Tools.SafeCopyData.API.ToolsData.API.Tools.Traversal Data.API.APIData.API.API.GenData.API.Doc.TypesData.API.Doc.CallData.API.Doc.Dir Data.API.Scan Data.API.THData.API.TutorialData.API.API.DSLDictsubstprepmkDictextDictmkUTCmkUTC'mkUTC_ parseUTC' parseUTC_?!?!?Binary_Binary DefaultValue DefValUtc DefValInt DefValBool DefValString DefValMaybe DefValList BasicTypeBTutcBTintBTboolBTbinaryBTstringAPITypeTyJSONTyBasicTyNameTyMaybeTyList ConversionSpecEnumseAlts SpecUnionsuFields FieldTypeftType ftReadOnly ftDefault ftComment SpecRecordsrFieldsRegExre_textre_regexUTCRangeur_lour_hiIntRangeir_loir_hiFilterFtrUTCFtrIntgFtrStrg SpecNewtypesnTypesnFilterSpec SpSynonymSpEnumSpUnionSpRecord SpNewtypePrefix MDComment FieldName _FieldNameTypeName _TypeNameAPINodeanName anCommentanPrefixanSpec anConvertThingThNode ThCommentAPI inIntRange inUTCRangemkRegExdefaultValueAsJsValueFromJSONWithErrsparseJSONWithErrs ParseFlags useDefaultsenforceReadOnlyFieldsenforceFiltersParserWithErrsStepInElemInFieldPositionFormatExpectedFmtOtherFmtUTC FmtBinaryExpected ExpString ExpObjectExpIntExpBoolExpArray JSONWarning JSONError SyntaxError RegexError UTCRangeError IntRangeErrorUnexpectedEnumValUnexpectedField MissingAlt MissingField BadFormat expectedArray expectedBool expectedIntexpectedObjectexpectedString badFormatprettyJSONError prettyStepprettyJSONErrorPositionsdefaultParseFlagsrunParserWithErrsTopfromJSONWithErrsfromJSONWithErrs'fromJSONWithErrs''decodeWithErrsdecodeWithErrs'parseJSONDefaultwithParseFlagsfailWithwithInt withIntRange withBinarywithBoolwithText withRegExwithUTC withUTCRange withVersion withFieldwithDefaultField.:..:: withUnionPPLinesppLinesPPpp inFrontOfindent NormEnumType NormUnionTypeNormRecordType NormTypeDeclNNewtype NTypeSynonym NEnumType NUnionType NRecordTypeNormAPI apiNormalFormdeclNFtypeDeclsFreeVarstypeDeclFreeVars typeFreeVarstypeDeclaredInApi typeUsedInApitypeUsedInTransitiveDeptransitiveDepstransitiveReverseDeps typeIsValid declIsValid apiInvariant substTypeDecl substTyperenameTypeUses MergeResult OnlyInRightInBoth OnlyInLeft ValueError InvalidAPICustomMigrationErrorTypeKind TKTypeSynonym TKNewtypeTKEnumTKUnionTKRecord ApplyFailureTableChangeErrorafCustomMessageDefaultMissingFieldBadDefaultValue afFieldName afFieldType afBadDefaultFieldDoesNotExistafMissingField FieldExists afTypeKindafExistingField DeclMalformedafDecl TypeMalformedafTypeafMissingTypes TypeInUse TypeWrongKind afTypeNameafExpectedKindTypeDoesNotExist afMissingType TypeExistsafExistingTypeValidateWarningValidateFailureChangelogIncompletevfChangelogVersionvfTargetVersion vfDifferencesChangelogEntryInvalidvfSuccessfullyAppliedvfFailedToApplyvfApplyFailure ApiInvalidvfInvalidVersionvfMissingDeclarationsCannotDowngrade vfFromVersion vfToVersionChangelogOutOfOrdervfLaterVersionvfEarlierVersion VersionExtra DevVersionRelease DataChecksCheckAll CheckCustomCheckStartAndEndNoChecksCustomMigrationsdatabaseMigrationdatabaseMigrationSchema typeMigrationtypeMigrationSchemafieldMigration MigrationTag APIChange ChCustomAll ChCustomTypeChRenameEnumValChDeleteEnumVal ChAddEnumValChRenameUnionAltChDeleteUnionAlt ChAddUnionAlt ChChangeField ChRenameField ChDeleteField ChAddField ChRenameType ChDeleteType ChAddType APIChangelog ChangesStart ChangesUpToAPIWithChangelogMigrateWarningMigrateFailuremigrateDataDumpmkRecordMigrationmkRecordMigrationSchema noDataChangesnoSchemaChangesshowVersionExtrachangelogStartVersionchangelogVersionvalidateChangesdataMatchesAPIprettyMigrateFailureprettyValidateFailureprettyValueErrorprettyValueErrorPositiongenerateMigrationKindsDocInfodoc_info_call_urldoc_info_type_urlBody OtherBodyJSONBody EmptyBodySample 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_linkcallHtmldirHtmlMarkdownMethodsMDMmdmSummaryPostfixmdmLinkmdmPpmdmFieldDefaultdefaultMarkdownMethodsmarkdownthingparseAPIparseAPIWithChangelogapiapiWithChangelog APINodeToolAPIToolToolrunTool ToolSettingswarnOnOmittedInstancenewtypeSmartConstructorsdefaultToolSettings simpleToolmkTool contramapToolreadToolsubTools apiNodeToolapiDataTypeTool apiSpecTool datatypesTooltype_nm rep_type_nmnodeTnodeRepTnodeConEnodeNewtypeConE nodeFieldE nodeAltConE nodeAltConPnewtypeProjectionEenumTool text_enum_nm map_enum_nmExampleexample samplesTool exampleTooljsonTool jsonTool'toJsonNodeToolfromJsonNodeToolfromJsonWithErrsNodeTool jsonTestsToolprop_decodesToprop_decodesTo'prop_resultsMatchRoundtriplensToolbinaryquickCheckTool safeCopyToolgenerate generateWithgenerateAPIToolsgenerateAPIToolsWith traversalToolapiAPIDV_utc DV_integer DV_boolean DV_stringDV_maybeDV_listBT_utc BT_integer BT_boolean BT_binary BT_stringTypeRef_TypeRefTY_jsonTY_basicTY_refTY_maybeTY_listField_fd_name_fd_type _fd_readonly _fd_default _fd_comment _cv_injection_cv_projection_ur_lo_ur_hi_ir_lo_ir_hiRegularExpression_RegularExpressionFT_utc FT_integer FT_string_sn_type _sn_filter SP_synonymSP_enumSP_union SP_record SP_newtype_an_name _an_comment _an_prefix_an_spec _an_convertAPISpec_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 apiAPISamplesapiAPISimpleTests$fToJSONAPINode extractAPIsubst_re utcFormat utcFormats aeson-0.8.0.2Data.Aeson.Types.InternalValueData.Aeson.Types.ClasstoJSONData.Aeson.Types.InstancesfromJSON$fIsStringAPITypeliftUTCliftMaybeUTCTime$fArbitraryBinary$fArbitraryText$fFromJSONBinary$fToJSONBinary$fLiftDefaultValue $fLiftRegEx $fShowRegEx $fEqRegEx$fFromJSONRegEx $fToJSONRegEx$fLiftUTCRange$fLiftIntRange $fToJSONThing$fToJSONTypeName$fToJSONFieldName $fToJSONSpec$fToJSONAPIType$fToJSONDefaultValue$fToJSONSpecEnum$fToJSONSpecUnion$fToJSONSpecRecord$fToJSONFieldType$fToJSONSpecNewtype$fToJSONFilter$fToJSONIntRange$fToJSONUTCRange$fToJSONBasicType $fToJSONCIattoparsec-0.12.1.2#Data.Attoparsec.ByteString.InternalParserbaseGHC.BaseMonadControl.Applicative ApplicativemodifyTopError withFilterwithStrictFieldrunParserWithErrswarning stepInsidewithNumtreatAsMissing$fFromJSONWithErrsVersion$fFromJSONWithErrsUTCTime$fFromJSONWithErrsText$fFromJSONWithErrsBinary$fFromJSONWithErrsBool$fFromJSONWithErrsInteger$fFromJSONWithErrsInt$fFromJSONWithErrs[]$fFromJSONWithErrsMaybe$fFromJSONWithErrs()$fFromJSONWithErrsValue$fMonadParserWithErrs$fAlternativeParserWithErrs$fApplicativeParserWithErrs$fToJSONJSONError$fToJSONExpected$fToJSONFormatExpected $fToJSONStep$fSafeCopyStep $fPPLinesStep $fPPLines(,) $fPPLines[]$fPPDefaultValue $fPPBasicType $fPPAPIType $fPPFieldName $fPPTypeName$fPPLinesValue$fPPText$fPPSet $fPPVersion$fPP[]transitiveClosure$fPPLinesNormTypeDecl ValidateData UpdateTypePos UpdateDeclPos Data.MaybeNothingghc-prim GHC.ClassesOrd Data.VersionVersion validateAfterviewChangelogReverse viewChangelogisChangelogOrdered changelogTags changeTags findUpdatePosvalidateChanges'APITableChangeapplyAPIChangesToAPI doChangeAPIapplyChangesToDatabase updateDeclAt updateTypeAtapplyChangeToDatadefaultValueForTypeDecode UpdateNamed UpdateMaybe UpdateList UpdateType UpdateUnion UpdateRecord UpdateHereCustomMigrationsTaggedreadCustomMigrations selectChangesapplyAPIChangeToAPI lookupTypeexpectRecordTypeexpectUnionTypeexpectEnumTypeapplyChangeToDatabase liftMigration withObjectwithObjectFieldwithObjectMatchingFieldswithObjectMatchingUnionwithArrayElems withMaybe withStringfieldKey fromFieldKeycompatibleDefaultValuecompatibleBasicDefaultValuedataMatchesNormAPI mergeMapsdiffMaps matchMaps ppATypeKind ppMemberWordppDiff ppDiffFields$fPPLinesValueError$fPPLinesApplyFailure$fPPLinesAPITableChange$fPPLinesValidateFailure$fPPLinesMigrateFailure$fPPLinesAPIChange $fPPTypeKind$fPPVersionExtra headersHtml paramsHtml paramsRowsbodyHtml viewsHtml samplesHtmlcall_dict_headercall_dict_paramcall_dict_samplecontainer_open 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 aggregate resourceHtml resource_dict call_dictresource_headingul_opencallul_closenodeheaderbodyntyperecordunion_enum_synonymmk_md_record_tablemk_md_union_table cleanComment summary_lines default_valuetype_md basic_type_md type_name_md prefix_md comment_mdblockversionljust utf8EncodeAlexAcc AlexAccSkip AlexAccNone AlexLastAcc AlexLastSkipAlexNone AlexReturn AlexTokenAlexSkip AlexErrorAlexEOFAlexAddrAlexA#TokenERRORStrgIntgVarIdenTypeIdenCommentUTCTIMEReadonlyFALSETRUENOTHINGTo Migration AlternativeDefaultChangedRenamedRemovedAddedChangesBasicEnumWithUnionJsonStringRecordQueryUTCIntegerBooleanGtEqLtEqEqualsCommaColonColColKetBraBInaryBarSemiPTokenAlexPosnAlexPn AlexInputByteignorePendingBytesalexInputPrevChar alexGetByte alexStartPosalexMovealexScanTokens alex_base alex_table alex_check alex_deflt alex_acceptutc_ 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_tkniUnbox$fFunctorAlexLastAcc HappyAddrHappyA#HappyStk Happy_IntList HappyCons EnumChange EnChRename EnChDeleteEnChAdd UnionChange UnChRename UnChDeleteUnChAdd FieldChange FldChChange FldChRename FldChDeleteFldChAddParseMHappyAny 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 happyDontSeq Data.MonoidMonoid $fMonoidTool applicativeEoptionalInstanceDfunSigDsimpleD simpleSigDgen_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 gen_se_tx gen_se_mp genTextMapQuickCheck-2.7.6Test.QuickCheck.Arbitrary arbitrary gen_sn_ex Arbitrary gen_sr_ex gen_su_ex gen_se_ex$fExampleUTCTime$fExampleValue$fExampleBinary $fExampleText $fExampleBool $fExampleInt $fExample[]$fExampleMaybeToJSONFromJSON gen_FromJSON gen_sn_to gen_sn_fm gen_sr_to gen_sr_fm gen_su_to gen_su_fm gen_se_to gen_se_fmgen_ingen_prmkInt jsonStrMap_p json_string_p fieldNameE typeNameETest.QuickCheck.PropertyProperty generateProp gen_sn_abarbitraryBoundedIntegral gen_sr_ab gen_su_ab gen_se_abarbitraryIntRange GHC.TypesIntarbitraryUTCRange time-1.4.2Data.Time.Clock.UTCUTCTime$fArbitraryUTCTimesafecopy-0.8.3Data.SafeCopy.SafeCopySafeCopy$fSafeCopyBinary traversalName traversalType traverser traverser'traversalRecordtraversalUnion$fFromJSONWithErrsThingconvert 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