h$mV}      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""#############$$&%None1 "#$%&'(-./1256789:<=>?8 5None1 "#$%&'(-./1256789:<=>?None2 "#$%&'(-./1256789:<=>?( compaREST6A description of how to effectfully tie knots in type v , using the m monad, and by sharing some d$ data among the recursive instances.  compaREST4Create some data that will be connected to this knot  compaRESTThis is what the knot will look like as a value to the inner computations  compaRESTOnce we're done and we're outside, tie the knot using the datum  compaRESTAn effectful memoization monad. compaRESTRun a memoized computation. compaRESTRun a potentially recursive computation. The provided key will be used to refer to the result of this computation. If during the computation, another attempt to run the computation with the same key is made, we run a tying-the-knot procedure.If another attempt to run the computation with the same key is made *after we're done*, we will return the memoized value. compaREST9Disambiguate memoized computations with an arbitrary tag. compaRESTthe computation to memoize compaRESTkey for memoization    None1 "#$%&'(-./1256789:<=>?None1 "#$%&'(-./1256789:<=>?% compaREST2An item related to some path relative to the root r.' compaREST#Like a differece list, but indexed.) compaRESTAll the possible ways to navigate between nodes in a heterogeneous tree form a quiver. The hom-sets of the free category constructed from this quiver are the sets of various multi-step paths between nodes. This is similar to a list, but indexed. The list is in reverse because in practice we append items at the end one at a time. %&'()+*,-./ -,)+*'(/%&.+5None1 "#$%&'(-./1256789:<=>?!6 9 compaREST5A set of interactions having common unifying features? compaRESTThe same issues can be rendered in multiple places and might require different ways of represnting them to the user.In practice each issue requires a maximum of two different representations: based on the context the issue might need to be rendered as "opposite" (<) @ for example when rendering non-breaking changes everything should be reversed (a consequence of the way we generate non-breaking changes).If _consumer_ doesn't have something, the element was "removed". If _producer_ doesn't have something, the element was "added".A compaRESTAn equivalence relation designating whether two issues are talking about the aspect of the schema. This is used to remove duplicates from the "reverse" error tree we get when we look for non-breaking changes. Generally if checking X->Y raises issue I, and checking Y->X raises issue J, I and J should be related.C compaRESTThis is certainly an issue, we can demonstrate a "counterexample"D compaRESTChange looks breaking but we don't have a complete comprehension of the problemE compaRESTWe don't really support this feature at all, outside structural comparisonF compaRESTThis is not an issue in itself, but a clarifying comment providing context for some other issuesG compaREST:We detected an issue with one of the input schemata itselfK compaRESTKindV compaRESTeither request or response data(789:;<=>?@ABFCDEGHIJKLMNOPQRSTUVWXYZ[\]^(KLMNOPQRSTUVWXYZHIJBFCDEG=>?@A:;<\978[]^None1 "#$%&'(-./1256789:<=>?"l compaREST A list of  AnItem r f#, but optimized into a prefix tree.r compaRESTThe number of leaves.y compaRESTSelect a subtree by prefix{ compaREST2Embed a subtree in a larger tree with given prefixjklmnopqrstuvwxyz{lmmjktsuvwxpqyz{ron None1 "#$%&'(-./1256789:<=>?$ compaREST The type FormulaF f r () describes (modulo contents of errors) boolean formulas involving variables, conjunctions, and disjunctions. These operations (and the generated algebra) are monotonous. This ensures that fixpoints always exist, i.e. that x = f x has at least one solution.   None1 "#$%&'(-./1256789:<=>?% None1 "#$%&'(-./1256789:<=>?& compaRESTHow to get from an a node to a b node compaRESTIf the given formula contains any issues, add another issue on top. Otherwise succeed.7.3. None1 "#$%&'(-./1256789:<=>?'? None1 "#$%&'(-./1256789:<=>?' None1 "#$%&'(-./1256789:<=>?(>I>INone1 "#$%&'(-./1256789:<=>?)G compaREST!Some entity which is product-like compaRESTNo required element foundNone1 "#$%&'(-./1256789:<=>?* compaRESTA boolean formula (without "not") represented as a Disjunctive Normal Form: the formula is a disjunction of a set of clauses, each of which is a conjunction of a set of some elementary formulas. Invariant: no two disjuncts imply eachother  None1 "#$%&'(-./1256789:<=>?+ compaRESTInvariant (for better memoization only): the "tail" of the trace is the "least" of the traces of the conjuncted schemata  None1 "#$%&'(-./1256789:<=>?- compaRESTA  whose type we know compaRESTType of a JSON valueNone1 "#$%&'(-./1256789:<=>?/ compaRESTA primitive structural condition for the "top level" of a JSON value (of a specific type) compaREST The order is lexicographical on a * Bool. compaRESTthis has the right Ord compaREST!formula for additional properties compaREST6schema for additional properties, Nothing means bottom((None1 "#$%&'(-./1256789:<=>?0None1 "#$%&'(-./1256789:<=>?DX* compaRESTSome (openapi-supported) feature that we do not support was encountered in the schema compaRESTWe couldn't prove that the branches of a oneOf are disjoint, and we will treat it as an anyOf, meaning we don't check whether the overlaps are excluded in a compatible way compaRESTThe schema is actually invalid compaREST2The schema contains a reference loop along "anyOf""allOf""oneOf". compaRESTProducer doesn't place any restrictions on the types, but the consumer does. List what types remain available in the consumer. compaRESTin the producer this field used to be handled as part of "additionalProperties", and the consumer this is a specific "properties" entry. Only thrown when this change actually causes other issues compaRESTin the consumer this field used to be handled as part of "additionalProperties", and the producer this is a specific "properties" entry. Only thrown when this change actually causes other issues compaRESTconsumer requires a property that is not required/allowed in the producer compaREST>producer allows a property that is not allowed in the consumer compaRESTproducer produces a specific value ($1), consumer has a condition that is not satisfied by said value compaRESTconsumer only expects a specific value which the producer does not produce. compaRESTconsumer declares a maximum numeric value ($1), producer doesn't compaRESTconsumer declares a maximum numeric value ($1), producer declares a weaker (higher) limit ($2) compaREST;consumer declares a minimum numeric value, producer doesn't compaRESTconsumer declares a minimum numeric value ($1), producer declares a weaker (lower) limit ($2) compaRESTconsumer declares that the numeric value must be a multiple of $1, producer doesn't compaRESTconsumer declares that the numeric value must be a multiple of $1, producer declares a weaker condition (multiple of $2) compaRESTconsumer declares a string/number format, producer declares none or a different format (TODO: improve via regex #32) compaRESTconsumer declares a maximum length of the string ($1), producer doesn't. compaRESTconsumer declares a maximum length of the string ($1), producer declares a weaker (higher) limit ($2) compaRESTconsumer declares a minimum length of the string ($1), producer doesn't. compaRESTconsumer declares a minimum length of the string ($1), producer declares a weaker (lower) limit ($2) compaRESTconsumer declares the string value must match a regex ($1), producer doesn't declare or declares different regex (TODO: #32) compaRESTconsumer declares the items of an array must satisfy some condition, producer doesn't compaRESTproducer and consumer declare that an array must be a tuple of a fixed length, but the lengths don't match compaRESTconsumer declares that the array is a tuple, but the producer doesn't, the length constraints match, but there were issues with the components compaRESTproducer declares that the array is a tuple, but the consumer doesn't, and there were issues with the components compaRESTconsumer declares that the array is a tuple, but the producer doesn't, and there aren't sufficient length constraints compaRESTconsumer declares a maximum length of the array ($1), producer doesn't. compaRESTconsumer declares a maximum length of the array ($1), producer declares a weaker (higher) limit ($2) compaRESTconsumer declares a minimum length of the array ($1), producer doesn't. compaRESTconsumer declares a minimum length of the array ($1), producer declares a weaker (lower) limit ($2) compaREST=consumer declares that items must be unique, producer doesn't compaRESTconsumer declares the properties of an object must satisfy some condition, producer doesn't compaREST7producer allows additional properties, consumer doesn't compaRESTconsumer declares a maximum number of properties in the object ($1), producer doesn't. compaRESTconsumer declares a maximum number of properties in the object ($1), producer declares a weaker (higher) limit ($2) compaRESTconsumer declares a minimum number of properties in the object ($1), producer doesn't. compaRESTconsumer declares a minimum number of properties in the object ($1), producer declares a weaker (lower) limit ($2) compaRESTproducer declares that the value must satisfy a disjunction of some conditions, but consumer's requirements couldn't be matched against any single one of them (TODO: split heuristic #71) compaRESTconsumer indicates that no values of this type are allowed, but we weren't able to conclude that in the producer (currently only immediate contradictions are checked, c.f. #70) compaRESTconsumer indicates that no values in a particular partition are allowed, but we weren't able to conclude this in the producer2>I2>INone1 "#$%&'(-./1256789:<=>?E|None1 "#$%&'(-./1256789:<=>?ENone1 "#$%&'(-./1256789:<=>?Gd compaRESTParams have different names compaREST?Consumer requires non-empty param, but producer gives emptyable compaREST7Consumer requires mandatory parm, but producer optional compaREST"Params encoded in different styles compaRESTOne of schemas not presented >I I>None1 "#$%&'(-./1256789:<=>?H compaRESTFragment parameterized by parameter. The dynamic part may be either reference to some parameter (in context of operation) or dereferenced parameter itself.None1 "#$%&'(-./1256789:<=>?I None1 "#$%&'(-./1256789:<=>?Ik >I >INone1 "#$%&'(-./1256789:<=>?INone2 "#$%&'(-./1256789:<=>?JU>>None1 "#$%&'(-./1256789:<=>?K > >None1 "#$%&'(-./1256789:<=>?KNone1 "#$%&'(-./1256789:<=>?KII None1 "#$%&'(-./1256789:<=>?Lk>I>I!None1 "#$%&'(-./1256789:<=>?M compaRESTParams from the PathItem compaRESTPath fragments traced from PathItem. Takes full list of operation-specific parameters>II>"None1 "#$%&'(-./1256789:<=>?OV0>I0I>&None1 "#$%&'(-./1256789:<=>?P compaRESTLike , but enforces a specific type list order. (Useful for deconstruction-directed type inference.)2#None1 "#$%&'(-./1256789:<=>?SW compaRESTA "jet" is a way of simplifying expressions from "outside". The "jetted" expressions should still be completely valid and correct without the jets. Jets just make the expression more "optimized" by identifying patterns and replacing the expressions with "better" ones that have the same sematics.The term "jet" in this context was introduced in the Urbit project: $https://urbit.org/docs/vere/jetting/&The pattern fits well for simplifying Behavior tree paths.None1 "#$%&'(-./1256789:<=>?Ur compaRESTAll changes that could be breaking are unsupported @ we don't know if there actually are any breaking changes. compaRESTforward C, D and F compaREST backward C, D and F, except those shadowed by A compaRESTforward and backward E (assumed to be the same anyway) compaRESTforward and backward G (assumed to be the same anyway)$None1 "#$%&'(-./1256789:<=>?V<'()'*+'*,-./-01-234567889:;<=>?@ABCDEFGHIJKLMNOPQRSTTUUVWXYZ[\]^_`abcddefghijklmnopqrstuvwxyz{|}~                                                                                              !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""#############$$%%%%%%%%%&&&&(compaREST-0.1.0.1-3bYGGvx9wcfDTyy6k7sjUVData.OpenApi.Compare.SubtreeData.OpenApi.Compare.PathsData.OpenApi.Compare.ReportData.OpenApi.Compare.CommonData.OpenApi.Compare.MemoData.OpenApi.Compare.OrphansData.OpenApi.Compare.Behavior$Data.OpenApi.Compare.PathsPrefixTreeData.OpenApi.Compare.Formula)Data.OpenApi.Compare.Report.Html.TemplateData.OpenApi.Compare.References"Data.OpenApi.Compare.Validate.Link)Data.OpenApi.Compare.Validate.OAuth2Flows&Data.OpenApi.Compare.Validate.Products(Data.OpenApi.Compare.Validate.Schema.DNF+Data.OpenApi.Compare.Validate.Schema.Traced.Data.OpenApi.Compare.Validate.Schema.TypedJson0Data.OpenApi.Compare.Validate.Schema.JsonFormula.Data.OpenApi.Compare.Validate.Schema.Partition+Data.OpenApi.Compare.Validate.Schema.Issues,Data.OpenApi.Compare.Validate.Schema.Process$Data.OpenApi.Compare.Validate.Schema#Data.OpenApi.Compare.Validate.Param*Data.OpenApi.Compare.Validate.PathFragment$Data.OpenApi.Compare.Validate.Header-Data.OpenApi.Compare.Validate.MediaTypeObject,Data.OpenApi.Compare.Validate.SecurityScheme1Data.OpenApi.Compare.Validate.SecurityRequirement$Data.OpenApi.Compare.Validate.Server"Data.OpenApi.Compare.Validate.Sums'Data.OpenApi.Compare.Validate.Responses)Data.OpenApi.Compare.Validate.RequestBody'Data.OpenApi.Compare.Validate.Operation%Data.OpenApi.Compare.Validate.OpenApiData.OpenApi.Compare.Report.JetData.OpenApi.Compare.Run Data.HListData.OpenUnion.ExtrabaseData.Typeable.InternalTypeableControl.Category>>><<<$comonad-5.0.8-7B69j8qZOLQ9p9g2dwIP3EControl.Comonad.Env.ClassaskControl.Comonad.Trans.EnvlocalControl.Comonadextract*pandoc-types-1.22.1-EbcKbgjut7s2wZi6fSiAH8Text.Pandoc.DefinitionPandoczipAllKnotTier$sel:onKnotFound:KnotTier$sel:onKnotUsed:KnotTier$sel:tieKnot:KnotTier MonadMemo MemoStatemodifyMemoNoncerunMemounknot memoWithKnotmemoTaggedWithKnot$fOrdInsOrdHashMap $fShowEnvT $fOrdEnvT$fEqEnvT$fOrdApiKeyLocation$fOrdApiKeyParams$fOrdHttpSchemeType$fOrdParamLocation$fOrdOpenApiItems $fOrdStyle$fOrdOpenApiType$fOrdXml$fOrdDiscriminator$fOrdAdditionalProperties $fOrdSchema$fOrdReferenced$fOrdReferenceAnItem DiffPathsPathsRootSnocAdditionalQuiverConstraints NiceQuiverstep catDiffPaths $fOrdPaths $fEqPaths$fTestEqualitykPaths$fCategorykPaths $fOrdAnItem $fEqAnItem $fShowPathsAnIssueBehavior OrientationForwardBackwardIssuableIssue describeIssue issueKind relatedIssues IssueKind CertainIssue ProbablyIssue UnsupportedComment SchemaInvalid BehavableBehavedescribeBehavior BehaviorLevelAPILevel ServerLevelSecurityRequirementLevelSecuritySchemeLevel PathLevelOperationLevelPathFragmentLevel RequestLevel ResponseLevel HeaderLevel PayloadLevel SchemaLevelTypedSchemaLevel LinkLevel CallbackLevel withClasstoggleOrientation anIssueKindrelatedAnIssues $fToJSONIssue$fToJSONAnIssue$fEqOrientation$fOrdOrientation$fShowOrientation $fEqIssueKind$fOrdIssueKind$fShowIssueKind $fOrdAnIssue $fEqAnIssue $fShowAnIssueAStepPathsPrefixTreePathsPrefixNodemap partitionfilter filterWithKeysize singletonemptyfromListnullfoldWithtoList takeSubtreelookupembed $fMonoidASet$fSemigroupASet $fToJSONASet$fMonoidPathsPrefixTree$fSemigroupPathsPrefixTree$fOrdPathsPrefixTree$fMonoidMergableObject$fSemigroupMergableObject$fToJSONPathsPrefixTree$fShowPathsPrefixTree $fOrdAStep $fEqAStep $fOrdASet$fEqASet $fShowASet$fEqPathsPrefixTreeFormulaFVarRefanErrorerrorsvariableeitherOf calculate maxFixpoint mapErrors$fApplicativeFormulaF$fFunctorSomeFormulaF$fFunctorFormulaFtemplateSubtreeCheckEnv SubtreeLevelcheckStructuralCompatibilitycheckSemanticCompatibilitySemanticCompatFormulaCompatFormula'CompatM$sel:unCompatM:CompatMProdCons$sel:producer:ProdCons$sel:consumer:ProdConsTracedTraced'Trace TraceRoot SteppableStepInsOrdHashMapKeyStep ClientSchema ServerSchematracedretraced stepTracedorientProdCons swapProdConscheckCompatibilitycheckSubstructurestructuralMaybestructuralMaybeWithstructuralList structuralEqiohmStructuraliohmStructuralWithrunCompatFormula embedFormulaissueAtanIssueanIteminvertIssueOrientationinvertIssueOrientationPstructuralIssueanyOfAt clarifyIssue$fSteppableInsOrdHashMapv$fSteppableTraceRootOpenApi$fApplicativeProdCons$fSwapEnvElementRoles'xFalse"$fSwapEnvElementRoles'ProdConsTrue$fSwapEnvRoles:$fSwapEnvRoles[] $fEqMemoKey $fOrdMemoKey$fFunctorCompatM$fApplicativeCompatM$fMonadCompatM$fMonadStateMemoStateCompatM $fEqProdCons $fOrdProdCons$fShowProdCons$fFunctorProdCons$fFoldableProdCons$fTraversableProdCons$fEqStep $fOrdStep $fShowStep $fEqStep0 $fOrdStep0 $fShowStep0$fShowVoidQuiver$fOrdVoidQuiver$fEqVoidQuiver InlineStep dereference$fSubtreeReferenced$fSteppableReferenceda$fIssuableLinkLevel $fSubtreeLink $fEqIssue $fOrdIssue $fShowIssueSecuritySchemeStepRefreshUrlsDontMatchHttpSchemeTypesDontMatchApiKeyParamsDontMatchOpenIdConnectUrlsDontMatchCustomHttpSchemesDontMatch"ConsumerDoesNotSupportImplicitFlow"ConsumerDoesNotSupportPasswordFlow+ConsumerDoesNotSupportClientCridentialsFlow+ConsumerDoesNotSupportAuthorizationCodeFlowSecuritySchemeNotMatchedOAuth2ImplicitFlowNotEqualOAuth2PasswordFlowNotEqual#OAuth2ClientCredentialsFlowNotEqual#OAuth2AuthorizationCodeFlowNotEqual ScopesMissingDifferentSecuritySchemesCanNotHaveScopesScopeNotDefinedSecurityRequirementNotMetUndefinedSecuritySchemeOAuth2FlowParamsStepOAuth2FlowsFlow6$fBehavableSecurityRequirementLevelSecuritySchemeLevel$fIssuableSecuritySchemeLevel"$fIssuableSecurityRequirementLevel$$fSubtreeOAuth2AuthorizationCodeFlow$$fSubtreeOAuth2ClientCredentialsFlow$fSubtreeOAuth2PasswordFlow$fSubtreeOAuth2ImplicitFlow$fSteppableOAuth2Flowt$fSubtreeOAuth2Flow $fSteppableOAuth2FlowsOAuth2Flow$fSubtreeOAuth2Flows $fEqBehave $fOrdBehave $fShowBehave $fEqIssue0 $fOrdIssue0 $fShowIssue0 ProductLike$sel:productValue:ProductLike$sel:required:ProductLike checkProductsDisjunctDNF LiteralDNFTopDNFSingleDisjunct BottomDNFfoldDNFforDNF$fBoundedMeetSemiLatticeDNF$fBoundedJoinSemiLatticeDNF $fLatticeDNF$fBoundedMeetSemiLatticeLiftA$fBoundedJoinSemiLatticeLiftA$fLatticeLiftA$fFunctorLiftA$fApplicativeLiftA$fEqDNF$fOrdDNF $fShowDNF $fEqDisjunct $fOrdDisjunct$fShowDisjunct PartitionPartitionLocationPHere PInPropertyPartitionChoice CByEnumValue CByPropertiesDiscriminatorMappingDiscriminatorStepPropertiesStepConjunctedWith Partitioned AllOfStep OneOfStep AnyOfStepItemsObjectStepItemsArrayStepAdditionalPropertiesStepNotStepImplicitTopSchema tracedAllOf tracedAnyOf tracedOneOf tracedItemstracedAdditionalPropertiestracedDiscriminatortracedPropertiestracedConjunct%$fSteppableDiscriminatorInsOrdHashMap$fSteppableSchemaDiscriminator$fSteppableSchemaInsOrdHashMap$fSteppableSchemaReferenced$fSteppableReferencedReferenced$fEqPartitionLocation$fOrdPartitionLocation$fShowPartitionLocation$fEqPartitionChoice$fOrdPartitionChoice$fShowPartitionChoice $fEqStep1 $fOrdStep1 $fShowStep1 $fEqStep2 $fOrdStep2 $fShowStep2 $fEqStep3 $fOrdStep3 $fShowStep3 ForeachType$sel:forNull:ForeachType$sel:forBoolean:ForeachType$sel:forNumber:ForeachType$sel:forString:ForeachType$sel:forArray:ForeachType$sel:forObject:ForeachType TypedValueTNullTBoolTNumberTStringTArrayTObjectJsonTypeNullBooleanNumberStringArrayObjectdescribeJSONType untypeValuefoldTypeforType_#$fBoundedMeetSemiLatticeForeachType#$fBoundedJoinSemiLatticeForeachType$fLatticeForeachType $fEqJsonType $fOrdJsonType$fShowJsonType$fShowForeachType$fOrdForeachType$fEqForeachType$fShowTypedValue$fOrdTypedValue$fEqTypedValue JsonFormula$sel:getJsonFormula:JsonFormula SomeCondition ConditionExactlyMaximumMinimum MultipleOf NumberFormat MaxLength MinLengthPattern StringFormatItems TupleItemsMaxItemsMinItems UniqueItems Properties MaxProperties MinPropertiesProperty$sel:propRequired:Property$sel:propFormula:Property$sel:propRefSchema:PropertyBound Exclusive Inclusive showBound showCondition showJSONValueshowJSONValueInlinesatisfiesTypedcheckNumberFormatcheckStringFormatsatisfiesFormula satisfies $fOrdBound$fOrdSomeCondition$fEqSomeCondition$fEqJsonFormula$fOrdJsonFormula$fShowJsonFormula$fLatticeJsonFormula#$fBoundedJoinSemiLatticeJsonFormula#$fBoundedMeetSemiLatticeJsonFormula $fEqProperty $fOrdProperty$fShowProperty $fEqBound $fShowBound$fFunctorBound$fShowSomeCondition$fShowCondition$fOrdCondition $fEqConditionIntersectionResultDisjointSameNewpartitionSchemapartitionRefSchema runPartitionMselectPartitionrunIntersectionMintersectSchemaintersectRefSchema tryPartition showPartition"$fBoundedMeetSemiLatticePartitions$fLatticePartitions$fEqIntersectionResult$fOrdIntersectionResult$fShowIntersectionResult$fEqPartitions$fOrdPartitions$fShowPartitions$fEqPartitionData$fOrdPartitionData$fShowPartitionDataInItemsInItem InPropertyInAdditionalProperty InPartitionOfType NotSupportedOneOfNotDisjoint InvalidSchemaUnguardedRecursionTypesRestrictedAdditionalToPropertyPropertyToAdditionalPropertyNowRequiredUnexpectedPropertyEnumDoesntSatisfyNoMatchingEnumNoMatchingMaximumMatchingMaximumWeakNoMatchingMinimumMatchingMinimumWeakNoMatchingMultipleOfMatchingMultipleOfWeakNoMatchingFormatNoMatchingMaxLengthMatchingMaxLengthWeakNoMatchingMinLengthMatchingMinLengthWeakNoMatchingPatternNoMatchingItemsTupleItemsLengthChanged ArrayToTuple TupleToArrayNoMatchingTupleItemsNoMatchingMaxItemsMatchingMaxItemsWeakNoMatchingMinItemsMatchingMinItemsWeakNoMatchingUniqueItemsNoMatchingPropertiesNoAdditionalPropertiesNoMatchingMaxPropertiesMatchingMaxPropertiesWeakNoMatchingMinPropertiesMatchingMinPropertiesWeakNoMatchingConditionTypeBecomesEmptyPartitionBecomesEmpty&$fBehavableTypedSchemaLevelSchemaLevel+$fBehavableTypedSchemaLevelTypedSchemaLevel&$fBehavableSchemaLevelTypedSchemaLevel$fIssuableSchemaLevel$fIssuableTypedSchemaLevel $fEqBehave0 $fOrdBehave0 $fShowBehave0 $fEqBehave1 $fOrdBehave1 $fShowBehave1schemaToFormula$fMonadWriterwSilent$fFunctorSilent$fApplicativeSilent $fMonadSilent$fSubtreeSchema InParamSchemaParamNameMismatchParamEmptinessIncompatible ParamRequiredParamPlaceIncompatibleParamStyleMismatchParamSchemaMismatchPathFragmentsDontMatch$fSteppableParamReferenced$fSubtreeParam'$fBehavablePathFragmentLevelSchemaLevel$fIssuablePathFragmentLevel$fEqEncodingStyle$fOrdEncodingStyle$fShowEncodingStylePathFragmentParam PathFragment StaticPath DynamicPath parsePath$fSteppablePathFragmentParam$fSubtreePathFragment$fEqPathFragment$fOrdPathFragment$fShowPathFragment$fFunctorPathFragment!$fBehavableHeaderLevelSchemaLevel$fIssuableHeaderLevel$fSteppableHeaderReferenced$fSubtreeHeaderConsumerDoesntHaveResponseCodeParamNotMatchedPathFragmentNotMatched NoRequestBodyWithStatusCode PayloadSchemaMediaTypeSchemaRequiredMediaEncodingMissingEncodingNotSupported$fIssuableOperationLevel&$fBehavableOperationLevelResponseLevel $fSteppableEncodingInsOrdHashMap"$fSteppableMediaTypeObjectEncoding'$fSteppableMediaTypeObjectInsOrdHashMap$$fSteppableMediaTypeObjectReferenced$fSubtreeEncoding$fSubtreeMediaTypeObject"$fBehavablePayloadLevelSchemaLevel$fIssuablePayloadLevel($fSteppableSecuritySchemeTypeOAuth2Flows+$fSteppableSecuritySchemeSecuritySchemeType$fSubtreeSecurityScheme$fSubtreeSecurityRequirementEnumValueNotConsumedConsumerNotOpenServerVariableNotDefinedServerNotMatched$fIssuableServerLevel $fSubtree[]$$fBehavableOperationLevelServerLevel $fSubtree[]0$fSteppable[][]$fEqServerUrlPart$fShowServerUrlPart$fFunctorServerUrlPart$fFoldableServerUrlPart$fTraversableServerUrlPart checkSumsInHeaderResponsePayload!$fSteppableResponsesInsOrdHashMap$fSteppableResponseReferenced $fSteppableResponseInsOrdHashMap!$fSteppableResponseInsOrdHashMap0!$fSteppableResponseInsOrdHashMap1"$fSteppableResponseMediaTypeObject$fSteppableResponsesReferenced$fSubtreeResponse#$fBehavableResponseLevelHeaderLevel$$fBehavableResponseLevelPayloadLevel$fIssuableResponseLevel$fSubtreeResponses $fEqStep4 $fOrdStep4 $fShowStep4 $fEqStep5 $fOrdStep5 $fShowStep5 InPayloadRequestBodyRequiredRequestMediaTypeNotFound#$fSteppableRequestBodyInsOrdHashMap%$fSteppableRequestBodyMediaTypeObject$fSubtreeRequestBody#$fBehavableRequestLevelPayloadLevel$fIssuableRequestLevelProcessedPathItems,$sel:unProcessedPathItems:ProcessedPathItemsProcessedPathItem$sel:path:ProcessedPathItem$sel:item:ProcessedPathItemOperationMethod GetMethod PutMethod PostMethod DeleteMethod OptionsMethod HeadMethod PatchMethod TraceMethodMatchedOperation$sel:operation:MatchedOperation $sel:pathParams:MatchedOperation&$sel:getPathFragments:MatchedOperationOperationCallbackCallbackPathsStepCallbacksUnsupportedPathFragmentStep PathItemParamOperationMethodStepMatchedPathStep InOperationOperationMissingAtPathNoPathsMatchedAllPathsFailedOperationServersStep EnvServerStepOperationCallbackStep OperationSecurityRequirementStepOperationResponsesStepOperationRequestBodyStepOperationParamsStepSecurityRequirementStep InRequestInParam InFragmentpathItemMethodprocessPathItems&$fBehavableOperationLevelCallbackLevel$fIssuableCallbackLevel$fSubtreeCallback$fBehavableAPILevelPathLevel$fIssuableAPILevel1$fBehavableOperationLevelSecurityRequirementLevel%$fBehavableOperationLevelRequestLevel*$fBehavableOperationLevelPathFragmentLevel$fSteppableMatchedOperation[]%$fSteppableMatchedOperationReferenced.$fSteppableMatchedOperationSecurityRequirement$$fSteppableMatchedOperationResponses&$fSteppableMatchedOperationReferenced0&$fSteppableMatchedOperationReferenced1$fSubtreeMatchedOperation"$fBehavablePathLevelOperationLevel$fIssuablePathLevel%$fSteppableCallbackProcessedPathItems$fSubtreeProcessedPathItems&$fSteppableMatchedPathItemPathFragment$$fSteppableMatchedPathItemReferenced*$fSteppableMatchedPathItemMatchedOperation,$fSteppableProcessedPathItemsMatchedPathItem$fSubtreeMatchedPathItem$fEqMatchedPathItem$fEqProcessedPathItems$fShowProcessedPathItems$fEqProcessedPathItem$fShowProcessedPathItem$fEqOperationMethod$fOrdOperationMethod$fShowOperationMethod $fEqStep6 $fOrdStep6 $fShowStep6 $fEqStep7 $fOrdStep7 $fShowStep7 $fEqStep8 $fOrdStep8 $fShowStep8 $fEqStep9 $fOrdStep9 $fShowStep9 $fEqIssue1 $fOrdIssue1 $fShowIssue1 $fEqBehave2 $fOrdBehave2 $fShowBehave2 $fEqBehave3 $fOrdBehave3 $fShowBehave3 $fEqBehave4 $fOrdBehave4 $fShowBehave4$fSteppableOpenApiInsOrdHashMap $fSteppableOpenApiInsOrdHashMap0 $fSteppableOpenApiInsOrdHashMap1 $fSteppableOpenApiInsOrdHashMap2 $fSteppableOpenApiInsOrdHashMap3 $fSteppableOpenApiInsOrdHashMap4 $fSteppableOpenApiInsOrdHashMap5 $fSteppableOpenApiInsOrdHashMap6$$fSteppableOpenApiProcessedPathItems$fSubtreeOpenApi ReportJet' ReportJetReportJetResultConstructReportJetconstructReportJet$fConstructReportJetkkManyf$fConstructReportJetkkMaybef$fJetArgNonEmpty $fJetArgUnion $fJetArgf$fConstructReportJetkk->f$fFunctorReportJetReportTreeStyleHeadersTreeStyleFoldingBlockquotesTreeStyle ReportConfig$sel:treeStyle:ReportConfig$sel:reportMode:ReportConfig ReportMode OnlyErrorsAll ReportStatusBreakingChangesNoBreakingChangesOnlyUnsupportedChanges ReportInput $sel:breakingChanges:ReportInput#$sel:nonBreakingChanges:ReportInput#$sel:unsupportedChanges:ReportInput$sel:schemaIssues:ReportInput CheckerOutput!$sel:forwardChanges:CheckerOutput"$sel:backwardChanges:CheckerOutputsegregateIssuesgenerateReport$fDefaultReportConfig$fMonoidReport$fSemigroupReport$fGenericReport$fEqReportMode$fGenericReportInput$fSemigroupReportInput$fMonoidReportInput$fToJSONReportInput$fGenericCheckerOutput$fSemigroupCheckerOutput$fMonoidCheckerOutput$fToJSONCheckerOutput runChecker runReport reassembleReassembleHListgetHHasHasAllHListHNilHCons singletonH$aeson-1.5.6.0-B9OtI9VBLiHCQs83ZG0jYcData.Aeson.Types.InternalValue@@>)open-union-0.4.0.0-DwxaFQqSl2rIAcxNNjr0veData.OpenUnion.Internal@> TryLiftUnion tryLiftUnionSingletonUnion