Y      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ 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 tuvwxyz{|}~NoneNone 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 wrappers_$Convert a default value to an Aeson . This differs from  as it will not round-trip with .: UTC default values are turned into strings.s  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_T  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_T^[]\TUVWXYZQRSNOPMLFKJIHGBCDE/01)*+,-.&'(#$%"! >A@?:;<=67892345 _6  ! "#$%&'()*+,-./0123456789:;<=>A@?BCDEFKJIHGLMNOPQRSTUVWXYZ[]\^_None-1`Like 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.aYParse 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.bLike _, 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 onlycOEach step may be into a field of an object, or a specific element of an array.fxA position inside a JSON value is a list of steps, ordered innermost first (so going inside an object prepends a step).g#Special format expected of a stringk^JSON type expected at a particular position, when a value of a different type was encounteredq9Represents 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 positionsRun 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 a. as it will not pass on the current position. Decode a  ByteString and run the JSON parserdIf this parser returns any errors at the current position, modify them using the supplied function.=Look up the value of a field, treating missing fields as null7Look 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 fieldsN`ab cdefghijklmnopqrstuvwxyz{|}~    6`abcdefghijklmnopqrstuvwxyz{|}~6q{zyxwvutsrkponmlgjihfcedb`a|}~7`ab cedfgjihkponmlq {zyxwvutsr|}~    None24 !"#$%&'()* !"#$%&'()*NoneE8Errors 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 it-5Represents the positions in a type to apply an update.<Represents the positions in a declaration to apply an updateThe canonical form of a record type is a map from fields to values; similarly a union is a map from fields to alternatives and an enum is a set of 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.Represents 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;GRecord migrations, which may change the schema of a single record; anduSingle field migrations, which may change only the type of the field (with the new type specified in the changelog).jFor database and record migrations, if the schema is unchanged, the corresponding function should return /.The db, rec 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.aWithin 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 0 1 instance).The initial version9The 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.21Whether to validate the dataset after this change %The earliest version in the changelog #The latest version in the changelog3KChangelog in order starting from oldest version up to newest. Entries are  (from, to, changes-oldest-first).4pChangelog in order as written, with latest version at the beginning, going back to older versions. Entries are  (to, from, changes-latest-first).5WIs the changelog in the correct order? If not, return a pair of out-of-order versions.6mSets of custom migration tags in the changelog for whole-database, single-record and single-field migrations70Sets of custom migration tags in a single change ECompute the normal form of an API, discarding extraneous information. 5Compute the normal form of a single type declaration.8+Check if a type is used anywhere in the API9dCheck if a type is used anywhere in the database (possibly in a transitive dependency of the root).:5Compute the transitive dependencies of a set of types;FCompute 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.=^Given a type to be modified, find the positions in which each type in the API must be updated XCheck 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.AApply the API changeB5This 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.C>Apply an update at the given position in a declaration's valueD6Apply an upate at the given position in a type's valueE`This actually applies the change to the data value, assuming it is already in the correct placeF`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.GH?+,-IJK.LMNOPStarting 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 migratedQ2  34567  RSTUVW89:;<XYZ[= 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\@A]^_`aBbCDEcdefghijklmnFopqrstuvwxyz{|}~x          iG"H?,+-KJI.ONMLPQ2  34567  RSTUVW89:;<XYZ[= >\@A]^_`aBbCDEcdefghijklmnFopqrstuvwxyz{|}~None-&PRecord of arguments that must be supplied to generate HTML documentation for a 54URL for individual call documentation from the index$URL for documentation of an API type Type for 4 response body, parameterised by possible JSON typesA non-empty, non-JSON response!A JSON response of the given typeAn empty responseExample response data from a 5*HTTP status code for this example responseType of example response Content of response, or / for empty response!<Documents a specific view of the result data available in a 5# View name$Type of result data returned%Free-form text description&3Query parameters that may be supplied for this view'<Documents a URL query parameter that may be included with a 5)Parameter name*Example 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 50 Header name1Example value for header2Free-form text description3Type of data in header43Is including the header with the request mandatory?5ADocuments a single method call on a resource in a web application7HTTP method being documented8!Relative URL path of the resource9Free-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 data?Example responses3 !"#$%&'()*+,-./0123456789:;<=>?@ABCDE2 !"#$%&'()*+,-./0123456789:;<=>?@ABCDE !"#$%&'()*+,-./012345 6789:;<=>?@ABCDENoneF"Generate a web page documenting a 5FFFNoneG(Generate a web page documenting all the 5s in a web application GG GNone4 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG4FG56789:;<=>?./01234'()*+,-!"#$%& BA@DCENoneO:Create human-readable API documentation in Markdown formatP8Document a single API comment or node in Markdown formatHIJKLMNOP HIJKLMNOP OHIJKLMNPHIJKLMNOPNone;BEncode a Haskell String to a list of Word8 values, in UTF8 format.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH1X,      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH None *+-./02345689:;=?BCDGHJKMyIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~QRSTQRSTQRSTjIJKLMNORQPSVUTW[ZYX\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~QRSTK L  None WA W aF is something that can generate TH declarations from a value of type a#. Tools can be combined using the  instance.X0Execute a tool to generate some TH declarations.YSettings 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 [.ZUGenerate a warning when an instance declaration is omitted because it already exists[+Default settings designed to be overridden.\5Construct a tool that does not depend on any settings]0Construct a tool that may depend on the settings^W is a contravariant functor_?Apply a tool that acts on elements of a list to the entire list`0Apply a tool that acts on nodes to an entire APIa]Apply a tool that acts on datatype nodes (i.e. those that are not synonyms) to an entire APIbFCreate a tool that acts on nodes from its action on individual specs.UVWXYZ[\]^_`abUVWXYZ[\]^_`abWXVUX\]^_`abYZZ[ UVWXYZ[\]^_`abNoneConstruct 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 NonecDTool 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)-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)d5Name of the type corresponding to the API node, e.g. JobIdeWName of the representation type corresponding to the API node, which differs from the d~ 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. _JobId`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_autof%The type corresponding to an API nodeg4The representation type corresponding to an API nodeh0The constructor for a newtype or record API nodei/A record field in an API node, as an expressionj<A prefixed constructor for a union or enum, as an expressionk8A prefixed constructor for a union or enum, as a patternlAThe projection function from a newtype API node, as an epxressioncdefghijkl cdefghijkl cdefghijklcdefghijkl Nonem3Tool to generate the maps between enumerations and Text strings named by n and o.nFor 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"oFor 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_FrameRatemnomnomnomno None1pbThe Example class is used to generate a documentation-friendly example for each type in the modelq*Generator for example values; defaults to  if not specifiedrGenerate a list of (type name, sample generator) pairs corresponding to each type in the API, with samples encoded as JSON. This depends on the p instances generated by s$. It generates something like this: \samples :: [(String, Gen Value)] samples = [("Foo", fmap toJSON (example :: Gen Foo)), ... ]sTool to generate p# instances for types generated by c. This depends on quickCheckTool. Generate an p7 instance for a newtype. If there is no filter, call q) on the underlying type; otherwise, use . Like S, if a regular expression filter is applied the instance must be defined manually. Generate an p instance for a record: instance Example Foo where example = sized $ \ x -> Foo <$> resize (x `div` 2) example <*> ... <*> resize (x `div` 2) example Generate an p instance for a union: Uinstance Example Foo where example = oneOf [ fmap Bar example, fmap Baz example ] Generate an p: instance for an enumeration, with no definition for the q2 method, because we can inherit the behaviour of : instance Example FoopqrspqrspqsrpqrsNonetTool to generate  and `# instances for types generated by c. This depends on m.uTool to generate  instance for an API nodevTool to generate ` instance for an API nodetuvtuvtuvtuvNoneMw)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 propertyxQuickCheck property that a Value. decodes to an expected Haskell value, using y=QuickCheck property that Haskell values can be encoded with toJSON and decoded with  to get the original valuewxywxywxywxyNonez2Tool to make lenses for fields in generated types.z{z{z{z{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.||||None}Tool to derive W instances for generated types. At present, this derives only base version instances.}}}}None~/Generate the datatypes corresponding to an API.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 Y to be overridden.~ Z[mrstwz|}~ ~[Zmstwz|}r~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:;<=>??@AABCCDEFGHHIJJKLMMNOPPQRSTUVWWXYZ[\]^_`abbcddeffghijklmnopqrstuvwxyz{|}~|       !"#$%&''()*++,-./001234566789:;<<=>?@ABCDEFGHIJKLMNOPQRSTUV 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 yz{|}~+28>>MMPPSWWZffRQONs      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~L)      !"#$%&'()*+,-./012345678 9 : ; ; < = > ? @ A B C D E F G H I J K K L M M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                             ] _                             %      api-tools-0.2Data.API.Doc.SubstData.API.UtilsData.API.Types Data.API.JSON Data.API.PPData.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.Tools 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 ThCommentAPIdefaultValueAsJsValueFromJSONWithErrsparseJSONWithErrsParserWithErrsStepInElemInFieldPositionFormatExpectedFmtOtherFmtUTC FmtBinaryExpected ExpString ExpObjectExpIntExpBoolExpArray JSONError SyntaxError RegexError UTCRangeError IntRangeErrorUnexpectedEnumValUnexpectedField MissingAlt MissingField BadFormat expectedArray expectedBool expectedIntexpectedObjectexpectedString badFormatprettyJSONError prettyStepprettyJSONErrorPositionsrunParserWithErrsTopfromJSONWithErrsdecodeWithErrsfailWithwithIntwithNum withIntRange withBinarywithBoolwithText withRegExwithUTC withUTCRange withVersion withField.:..::PPLinesppLinesPPpp inFrontOfindent MergeResult OnlyInRightInBoth OnlyInLeft ValueError InvalidAPICustomMigrationErrorTypeKindTKEnumTKUnionTKRecord ApplyFailureTableChangeErrorafCustomMessageDefaultMissingFieldBadDefaultValue afFieldName afFieldType afBadDefaultFieldDoesNotExistafMissingField FieldExists afTypeKindafExistingField DeclMalformedafDecl TypeMalformedafTypeafMissingTypes TypeInUse TypeWrongKind afTypeNameafExpectedKindTypeDoesNotExist afMissingType TypeExistsafExistingTypeValidateWarningValidateFailureChangelogIncompletevfChangelogVersionvfTargetVersion vfDifferencesChangelogEntryInvalidvfSuccessfullyAppliedvfFailedToApplyvfApplyFailure ApiInvalidvfInvalidVersionvfMissingDeclarationsCannotDowngrade vfFromVersion vfToVersionChangelogOutOfOrdervfLaterVersionvfEarlierVersion NormEnumType NormUnionTypeNormRecordType NormTypeDeclNNewtype NTypeSynonym NEnumType NUnionType NRecordTypeNormAPI VersionExtra DevVersionRelease DataChecksCheckAll CheckCustomCheckStartAndEndNoChecksCustomMigrationsdatabaseMigrationdatabaseMigrationSchemarecordMigrationrecordMigrationSchemafieldMigration MigrationTag APIChange ChCustomAllChCustomRecordChRenameEnumValChDeleteEnumVal ChAddEnumValChRenameUnionAltChDeleteUnionAlt ChAddUnionAlt ChChangeField ChRenameField ChDeleteField ChAddField ChRenameType ChDeleteType ChAddType APIChangelog ChangesStart ChangesUpToAPIWithChangelogMigrateWarningMigrateFailuremigrateDataDumpshowVersionExtrachangelogStartVersionchangelogVersion apiNormalFormdeclNFvalidateChangesdataMatchesAPIprettyMigrateFailureprettyValidateFailureprettyValueErrorprettyValueErrorPositiongenerateMigrationKindsDocInfodoc_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 ToolSettingswarnOnOmittedInstancedefaultToolSettings simpleToolmkTool contramapToolsubTools apiNodeToolapiDataTypeTool apiSpecTool datatypesTooltype_nm rep_type_nmnodeTnodeRepTnodeConE nodeFieldE nodeAltConE nodeAltConPnewtypeProjectionEenumTool text_enum_nm map_enum_nmExampleexample samplesTool exampleTooljsonTooltoJsonNodeToolfromJsonNodeTool jsonTestsToolprop_decodesToprop_resultsMatchRoundtriplensToolbinaryquickCheckTool safeCopyToolgenerategenerateAPIToolsgenerateAPIToolsWithapiAPIDV_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.6.2.1Data.Aeson.Types.InternalValueData.Aeson.Types.ClasstoJSONfromJSONliftMaybeUTCTimemkRegEx$fArbitraryBinary$fArbitraryText$fFromJSONBinary$fToJSONBinary $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.2Data.Attoparsec.Text.InternalParserbaseGHC.BaseMonadControl.Applicative ApplicativemodifyTopErrorwithStrictFieldrunParserWithErrs stepInside$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[] ValidateData UpdateTypePos UpdateDeclPos Data.MaybeNothingghc-prim GHC.ClassesOrd Data.VersionVersion validateAfterviewChangelogReverse viewChangelogisChangelogOrdered changelogTags changeTags typeUsedInApitypeUsedInApiTabletransitiveDepstransitiveSpedtransitiveClosure findUpdatePosvalidateChanges'APITableChangeapplyAPIChangesToAPI doChangeAPIapplyChangesToDatabase updateDeclAt updateTypeAtapplyChangeToDatadefaultValueForTypeDecode UpdateNamed UpdateMaybe UpdateList UpdateType UpdateUnion UpdateRecord UpdateHereCustomMigrationsTaggedreadCustomMigrationstypeDelcsFreeVarstypeDelcFreeVars typeFreeVarsmapTypeDeclFreeVarsmapTypeFreeVarstypeDeclaredInApirenameTypeUses typeIsValid declIsValid apiInvariant selectChangesapplyAPIChangeToAPI lookupTypeexpectRecordTypeexpectUnionTypeexpectEnumTypeapplyChangeToDatabase liftMigration withObjectwithObjectFieldwithObjectMatchingFieldswithObjectMatchingUnionwithArrayElems withMaybe withStringfieldKey fromFieldKeycompatibleDefaultValuecompatibleBasicDefaultValuedataMatchesNormAPI mergeMapsdiffMaps matchMaps ppATypeKind ppMemberWordppDiff ppDiffFields$fPPLinesValueError$fPPLinesApplyFailure$fPPLinesAPITableChange$fPPLinesValidateFailure$fPPLinesMigrateFailure$fPPLinesNormTypeDecl$fPPLinesAPIChange $fPPTypeKind$fPPVersionExtrarenderBasicType 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 FldChDeleteFldChAdd HappyIdentityHappyAny 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_ happyIdentityhappyRunIdentity happyThen happyReturn happyThen1 happyReturn1 happyError'parseparse_with_changeloghappySeq happyErrorfldChangeToAPIChangeunionChangeToAPIChangeenumChangeToAPIChangeparseVerparseVersionExtra happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeq$fMonadHappyIdentity$fApplicativeHappyIdentity$fFunctorHappyIdentity Data.MonoidMonoid $fMonoidTool applicativeEoptionalInstanceDfunSigDsimpleD simpleSigDgen_sy gen_sn_dt gen_sr_dt gen_su_dt gen_se_dtnewtype_prj_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[]$fExampleMaybeToJSON 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_pr alternativesmkInt 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$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