#pragma once
// @generated
// Glean.Schema.Gen.Cpp definitions for fbcode/glean/lang/clang/schema.h
// by //glean/hs:predicates using --cpp

#include <tuple>
#include <boost/variant.hpp>
#include "glean/cpp/glean.h"



namespace facebook {

namespace glean {

namespace cpp {

namespace schema {

constexpr int version = 1;

namespace Sys {

struct Blob;

} // namespace Sys

namespace Src {

struct RelByteSpan;

struct Range;

struct RangeContains;

struct PackedByteSpansGroup;

struct Loc;

enum class Language;

enum class IndexFailureReason;

struct IndexFailure;

struct FileLines;

struct FileLanguage;

struct FileDigest;

struct File;

struct ByteSpan;

struct ByteSpanContains;

struct FileLocation;

struct ByteRange;

} // namespace Src

namespace Search {

namespace Python {

struct QueryToScopeCase;

struct PythonNameCase;

} // namespace Python

namespace Pp {

struct SearchByName;

} // namespace Pp

namespace Java {

struct QueryToScopeCase;

struct NameCase;

} // namespace Java

namespace Hack {

struct QueryToScopeCase;

struct HackNameCase;

struct HackInAutoImportedNamespace;

} // namespace Hack

namespace Flow {

struct TypeDeclarationAsDeclaration;

struct QueryToScopeCase;

struct FlowModuleNameCase;

} // namespace Flow

namespace Cxx {

struct QueryToQNameCase;

struct QueryToNSQNameCase;

struct CxxRecordCase;

struct CxxNamespaceCase;

} // namespace Cxx

namespace Anglelang {

struct NameLowerCase;

} // namespace Anglelang

} // namespace Search

namespace Scip {

enum class TextEncoding;

struct SymbolName;

struct SymbolDocumentation;

struct SymbolDisplayName;

struct Symbol;

struct SomeEntity;

struct ReferenceTarget;

struct Reference;

enum class ProtocolVersion;

struct Location;

struct LocalName;

struct IsImplemented;

struct IsImplementation;

struct Entity;

struct EntityDefinition;

struct EntityLocation;

struct EntityUses;

struct FileEntityXRefLocation;

struct ResolveLocation;

struct SearchBySymbol;

struct Documentation;

struct DisplayNameSymbol;

struct DisplayName;

struct DefinitionUses;

struct DefinitionName;

struct DefinitionDocumentation;

struct Definition;

} // namespace Scip

namespace Python {

namespace Branches {

struct Root;

struct FileToRoot;

struct DirectXRefByFile;

} // namespace Branches

struct XRefsViaNameByTarget;

struct XRefsViaName;

struct XRefViaName;

struct XRefsViaNameByFile;

struct VariableDeclaration;

struct VariableBySName;

struct TypeInfo;

struct Type;

struct StringLiteral;

struct SearchVariableByName;

struct SearchVariableByLowerCaseName;

struct SearchModuleByName;

struct SearchModuleByLowerCaseName;

struct SearchMethodByName;

struct SearchMethodByLowerCaseName;

struct SearchFunctionByName;

struct SearchFunctionByLowerCaseName;

struct SearchFieldByName;

struct SearchFieldByLowerCaseName;

struct SearchClassByName;

struct SearchClassByLowerCaseName;

struct SNameToName;

struct SName;

struct ResolveOriginalName;

struct Parameter;

struct NameToSName;

struct Name;

struct ModuleDefinition;

struct ModuleBySName;

struct Module;

struct MethodOverrides;

struct MethodOverriden;

struct MethodByLocalNameStr;

struct ImportStatementByAsSName;

struct ImportStatementByAsName;

struct ImportStatement;

struct ImportStarsByFile;

struct ImportStarStatement;

struct ImportStarLocation;

struct FunctionDeclaration;

struct FunctionBySName;

struct DerivedClassToBase;

struct Definition;

struct DefinitionLocation;

struct DefinitionsByFile;

struct IsTopLevelDefinition;

struct DeclarationContainer;

struct FunctionDefinition;

struct VariableDefinition;

struct Declaration;

struct DeclarationDefinition;

struct DeclarationDocstring;

struct DeclarationLocation;

struct DeclarationReference;

struct DeclarationToName;

struct DeclarationUses;

struct DeclarationWithLocalName;

struct DeclarationWithName;

struct DeclarationWithSName;

struct DeclarationsByFile;

struct DefinitionDeclaration;

struct DirectXRef;

struct DirectXRefsByFile;

struct IsAbstract;

struct IsTopLevelDeclaration;

struct NonImportDeclaration;

struct SNameWithDeclaration;

} // namespace Python

namespace Yaml {

struct XRefViaName;

struct XRefsByFile;

} // namespace Yaml

namespace Python {

struct Contains;

struct ContainingTopLevelDeclaration;

struct ContainedByTopLevelDeclaration;

struct ContainedBy;

struct ClassDefinition;

struct ClassDeclaration;

struct ClassBySName;

struct CalleeToCaller;

struct BaseClassToDerived;

struct Argument;

struct CallArgument;

struct FileCall;

} // namespace Python

namespace Pp1 {

struct Use;

struct Undef;

struct Macro;

struct Include;

struct DefineUse;

struct DefineLowerCase;

struct Define;

} // namespace Pp1

namespace Lsif {

namespace Types {

struct ToolInfo;

} // namespace Types

} // namespace Lsif

namespace Scip {

struct Metadata;

} // namespace Scip

namespace Lsif {

namespace Types {

enum class SymbolKind;

} // namespace Types

} // namespace Lsif

namespace Scip {

struct EntityKind;

struct SearchByNameKind;

struct SymbolKind;

} // namespace Scip

namespace Lsif {

namespace Types {

struct RangeSpan;

struct ToSrcRange;

} // namespace Types

} // namespace Lsif

namespace Scip {

struct DefinitionLocation;

struct FileRange;

struct FileXLangSymbolRef;

struct ReferenceLocation;

} // namespace Scip

namespace Lsif {

namespace Types {

enum class LanguageId;

} // namespace Types

} // namespace Lsif

namespace Scip {

struct FileLanguage;

struct TagDefinition;

} // namespace Scip

namespace Lsif {

namespace Types {

struct FromSrcRange;

} // namespace Types

struct SomeEntity;

struct Reference;

struct Range;

struct ProjectDocument;

struct Project;

struct PackageInformation;

struct NameLowerCase;

struct NameDefinition;

struct Name;

struct MonikerSymbolKind;

struct MonikerScheme;

enum class MonikerKind;

struct MonikerId;

struct MonikerDefinition;

struct Moniker;

struct Metadata;

struct Location;

struct HoverText;

struct HoverContent;

struct Entity;

struct EntityDefinition;

struct EntityKind;

struct EntityLocation;

struct EntityUses;

struct FileEntityXRefLocation;

struct ResolveLocation;

struct SearchByExactLocation;

struct SearchByExactLocationAndName;

struct SearchByMoniker;

struct SearchByName;

struct SearchNonLocalByLocation;

struct TagDefinition;

struct Document;

struct DefinitionUse;

struct DefinitionMoniker;

struct DefinitionLocation;

struct DefinitionKind;

struct DefinitionHover;

struct Definition;

struct Declaration;

} // namespace Lsif

namespace Kotlin {

namespace Alpha {

struct VariableParent;

struct VariableDeclaration;

struct TypeArg;

struct Type;

struct DeclarationLocation;

struct Declaration;

struct DeclarationFileLocation;

struct ExtendsDeclaration;

struct FileDeclarations;

struct MethodDeclaration;

struct ParentDeclaration;

} // namespace Alpha

} // namespace Kotlin

namespace Search {

namespace Kotlin {

struct SearchByQName;

} // namespace Kotlin

} // namespace Search

namespace Symbolid {

namespace Kotlin {

struct LookupDeclaration;

struct LookupMethodDeclaration;

} // namespace Kotlin

} // namespace Symbolid

namespace Kotlin {

namespace Alpha {

struct ContainsDeclaration;

struct ClassMember;

struct ClassDeclaration;

} // namespace Alpha

} // namespace Kotlin

namespace Javakotlin {

namespace Alpha {

struct Type;

struct QName;

struct Path;

struct NameLowerCase;

struct Name;

struct MethodName;

} // namespace Alpha

} // namespace Javakotlin

namespace Java {

namespace Alpha {

struct XRefTarget;

struct XRefFile;

struct XRef;

struct Wildcard;

struct TypeVar;

struct TypeParam;

struct TypeOfTypeArgs;

struct TypeArg;

struct PrimitiveType;

struct PackageDeclaration;

struct ObjectType;

enum class Modifier;

struct ParameterDeclaration;

struct InterfaceInheritance;

struct Inheritance;

struct ImportDeclaration;

struct FileXRefs;

struct ExecutableDefinition;

struct ExecutableDefnLocation;

struct LocalDeclaration;

struct Definition;

struct DefinitionLocation;

struct EnumDeclaration;

struct FieldDeclaration;

struct InterfaceDeclaration;

struct MethodDeclaration;

struct Declaration;

struct DeclarationAnnotations;

struct DeclarationComment;

struct DeclarationLocation;

struct DeclarationType;

struct DeclarationUses;

struct DeclarationXRefTarget;

struct ExtendedByDeclaration;

struct ExtendsDeclaration;

struct FileDeclarations;

struct ParentDeclaration;

struct QNameToDefinition;

struct XRefOfType;

struct XRefTargetDeclaration;

} // namespace Alpha

} // namespace Java

namespace Search {

namespace Java {

struct SearchByQName;

} // namespace Java

} // namespace Search

namespace Symbolid {

namespace Java {

struct LookupDeclaration;

struct LookupMethodDeclaration;

} // namespace Java

} // namespace Symbolid

namespace Java {

namespace Alpha {

struct DeclOfExecutableDefn;

struct DeclOfDefn;

struct ContainsDeclaration;

struct ConstructorDeclaration;

struct ClassDeclaration;

struct BaseType;

struct Type;

struct ArrayType;

struct Annotation;

struct AnnotatedClass;

} // namespace Alpha

} // namespace Java

namespace Indexer {

struct Config;

} // namespace Indexer

namespace Hs {

struct ValBind;

struct UnitName;

struct TypeSynDecl;

struct TypeFamilyDecl;

struct TypeArg;

struct TyVarBind;

enum class TupleSort;

struct TyConSort;

struct TyCon;

enum class Specificity;

struct SourceModule;

struct SigDecl;

struct RefTarget;

enum class RefKind;

struct RefSpan;

struct XRef;

struct RecordFieldDecl;

struct PatSynDecl;

struct PatBind;

struct OccNameLowerCase;

enum class Namespace;

struct OccName;

struct NameSort;

struct Name;

struct ModuleSource;

struct ModuleName;

struct ModuleDeclarations;

struct Module;

struct MethDecl;

struct LitType;

struct InstanceDecl;

struct InstanceBindToDecl;

struct InstanceBind;

struct FileXRefs;

struct DeclarationLocation;

struct Declaration;

struct DeclarationOfName;

struct DeclarationSpan;

struct DataDecl;

struct ConstrDecl;

struct ClassDecl;

struct ArgFlag;

struct Type;

} // namespace Hs

namespace Hack {

enum class Visibility;

enum class Variance;

struct UserAttribute;

struct TypedefDeclaration;

enum class TypeConstKind;

struct TypeConstDefinition;

struct Type;

struct TraitDeclaration;

struct StringLiteral;

struct SearchTypedefByLowerCaseName;

struct SearchTypeConstByLowerCaseName;

struct SearchTraitByLowerCaseName;

struct SearchPropertyByLowerCaseName;

struct SearchNamespaceByLowerCaseName;

struct SearchModuleByLowerCaseName;

struct SearchMethodByLowerCaseName;

struct SearchInterfaceByLowerCaseName;

struct SearchGlobalConstByLowerCaseName;

struct SearchFunctionByLowerCaseName;

struct SearchEnumeratorByLowerCaseName;

struct SearchEnumByLowerCaseName;

struct SearchClassConstByLowerCaseName;

struct SearchClassByLowerCaseName;

enum class ReifyKind;

enum class ReadonlyKind;

struct QName;

struct PropertyDefinition;

struct Parameter;

struct Signature;

struct Occurrence;

struct NamespaceQName;

struct NamespaceDeclaration;

struct NameLowerCase;

struct Name;

struct ModuleMembership;

struct ModuleDefinition;

struct ModuleDeclaration;

struct MethodOverrides;

struct MethodOverridden;

struct MethodOccurrence;

struct InterfaceDeclaration;

struct IndexerInputsHash;

struct GlobalNamespaceAlias;

struct GlobalConstDefinition;

struct GlobalConstDeclaration;

struct FunctionDeclaration;

struct FieldClassConst;

struct ShapeKV;

struct Hint;

struct Enumerator;

struct EnumDefinition;

struct EnumDeclaration;

struct Definition;

struct Context_;

struct ContainerDeclaration;

struct ContainerDeclarationQName;

struct ContainerParent;

struct Declaration;

struct DeclarationComment;

struct DeclarationLocation;

struct DeclarationName;

struct DeclarationNamespace;

struct DeclarationSource;

struct DeclarationSpan;

struct DeclarationTarget;

struct FileDeclarations;

struct MemberCluster;

struct ModuleChild;

struct ModuleParent;

struct NamespaceMember;

struct SearchClassByName;

struct SearchClassConstByName;

struct SearchEnumByName;

struct SearchEnumeratorByName;

struct SearchFunctionByName;

struct SearchGlobalConstByName;

struct SearchInterfaceByName;

struct SearchMethodByName;

struct SearchModuleByName;

struct SearchNamespaceByName;

struct SearchPropertyByName;

struct SearchTraitByName;

struct SearchTypeConstByName;

struct SearchTypedefByName;

struct XRefTarget;

struct TargetUses;

struct TargetUsesAbs;

struct XRef;

struct FileXRefs;

struct TypeInfo;

} // namespace Hack

namespace Search {

namespace Hack {

struct SearchByName;

struct SearchFunctionInNamespace;

struct SearchGlobalConstInNamespace;

struct SearchInContainer;

struct SearchInContainerNoProperty;

struct SearchInContainerOrEnum;

struct SearchInContainerOrEnumNoProperty;

struct SearchInEnum;

struct SearchInNamespace;

struct SearchModule;

struct SearchNamespace;

struct SearchNamespacedDecl;

struct SearchPropertyInContainer;

struct SearchTypeInNamespace;

} // namespace Hack

} // namespace Search

namespace Hack {

struct InheritedMembers;

struct MethodDeclaration;

struct PropertyDeclaration;

struct TypeConstDeclaration;

struct ContainerChild;

enum class ConstraintKind;

struct Constraint;

struct TypeParameter;

struct FunctionDefinition;

struct InterfaceDefinition;

struct MethodDefinition;

struct TraitDefinition;

struct TypedefDefinition;

struct ClassDefinition;

struct ClassDeclaration;

struct ClassConstDefinition;

struct ClassConstDeclaration;

struct AttributeToDefinition;

struct AttributeToDeclaration;

struct AttributeHasParameter;

struct Argument;

struct CallArgument;

struct FileCall;

} // namespace Hack

namespace Graphql {

struct VariableDef;

struct Value;

struct UnionTypeDef;

struct SelectionSet;

struct ScalarTypeDef;

enum class OperationKind;

struct Operation;

struct ObjectTypeDef;

struct NameLowerCase;

struct InterfaceTypeDef;

struct InputValueDef;

struct InputObjectTypeDef;

struct InlineFragment;

struct FragmentSpread;

struct Fragment;

struct FieldDef;

struct Field;

struct EnumTypeDef;

enum class DirectiveDefLocation;

struct DirectiveDef;

struct Directive;

struct Declaration;

struct DeclarationLocation;

struct DeclarationName;

struct DeclarationUses;

struct FileDeclarations;

struct SearchByName;

struct XRef;

struct FileXRefs;

struct DeclHasName;

struct BelongToConfig;

struct Argument;

} // namespace Graphql

namespace Glean {

namespace Test {

struct nothingTest;

struct WrappedStringPair;

struct ViaStringPair;

struct Unbound2;

struct Unbound;

struct TreeToTree;

struct Tree;

struct Sum_;

struct StringPairBox;

struct StringPair;

struct StoredRevStringPairWithRev;

struct StoredRevStringPairWithA;

struct StoredRevStringPairSum;

struct StoredRevStringPair;

struct StoredDualStringPair;

struct SkipRevEdge;

struct SameString;

struct RevStringPairs;

struct RevStringPairRec;

struct RevStringPair;

struct RevRevStringPair;

struct RevEdge;

struct ReflStringPair;

struct RefRef;

struct Ref;

struct Qux;

struct Predicate_0;

struct NodePair;

struct Node;

struct Name;

struct MatchOneAlt;

struct LeftOr2;

struct LeftOr;

struct KeyValue;

struct IsThree;

struct IsParent;

struct IsGlean;

struct FooToFoo;

struct Foo;

struct Expr;

enum class Enum_;

struct Rec;

struct EmptyStoredStringPair;

struct EmptyPred;

struct EdgeWrapper;

struct EdgeSum;

struct EdgeFromNotA;

struct Edge;

struct DualStringPair;

struct DerivedKeyValue2;

struct DerivedKeyValue;

struct Bar;

enum class KitchenSink_enum_;

struct KitchenSink;

struct Predicate_;

} // namespace Test

} // namespace Glean

namespace Gencode {

enum class GenCodeVariant;

struct GenCodeSignature;

struct GenCodeCommand;

struct GenCodeClass;

struct GenCodeBySource;

struct GenCode;

} // namespace Gencode

namespace Flow {

struct XRef;

struct TypeImportDeclaration;

struct TypeExport;

struct TypeDeclarationReference;

struct TypeDeclarationInfo;

struct TypeDeclaration;

struct Type;

struct StringToFileModule;

struct SourceOfTypeExport;

struct SourceOfExport;

struct SomeDeclaration;

struct SomeEntity;

} // namespace Flow

namespace Search {

namespace Flow {

struct FlowSearchByNameNonImport;

} // namespace Flow

} // namespace Search

namespace Flow {

struct SearchTypeDeclarationByName;

struct SearchTypeDeclarationByLowerCaseName;

struct SearchTypeByModuleExport;

struct SearchModuleByLowerCaseName;

struct SearchMemberDeclarationByName;

struct SearchMemberDeclarationByLowerCaseName;

struct SearchDeclarationByName;

struct SearchDeclarationByLowerCaseName;

struct SearchByNameModule;

struct SearchByName;

struct SearchByModuleName;

struct SearchByModule;

struct SearchByFileModule;

struct Range;

struct Name;

struct ModuleTypeExport;

struct ModuleNameLowerCase;

struct ModuleLocationByFile;

struct ModuleLocation;

struct ModuleExport;

struct ModuleDoc;

struct ModuleContains;

struct ModuleComments;

struct Module;

struct MemberDeclarationReference;

struct MemberDeclarationInfo;

struct MemberDeclaration;

struct LocalDeclarationReference;

struct ImportDeclaration;

struct FlowXRefDeclInfo;

struct FlowTypeImportXRef;

struct FlowTypeExportLocation;

struct FlowTypeEntityImportUses;

struct FlowSameModule;

struct FlowModuleNamespaceXRef;

struct FlowImportXRef;

struct FlowExportLocation;

struct FlowEntityUsesAll;

struct FlowEntityImportUses;

struct FlowCompatibleExport;

struct FileXRef;

struct FileOfStringModule;

struct FileDeclaration;

struct Export;

struct Documentation;

struct DeclarationUses;

struct DeclarationSignature;

struct DeclarationNameSpan;

struct DeclarationLocation;

struct DeclarationInfo;

struct Declaration;

} // namespace Flow

namespace Fbthrift {

struct XRefTarget;

struct TypedConst;

struct TypedConstT;

struct UnionFieldVal;

struct UnionVal;

struct TypeDefType;

struct Target;

struct StructuredAnnotation;

struct StructFieldValValue;

struct StructFieldVal;

struct StructVal;

struct ServiceParent;

struct ServiceName;

struct ServiceInteractionFunctions;

struct ServiceDefinition;

struct ServiceChild;

struct SearchByName;

struct ResultSink;

enum class Qualifier;

struct QualName;

enum class PrimitiveType;

struct PackageName;

struct Package;

struct NamespaceValue;

struct NamespaceName;

struct Namespace;

enum class NamedKind;

struct NamedType;

struct NamedDecl;

struct NameLowerCase;

struct MapType;

struct Loc;

struct XRef;

struct KeyValue;

struct InteractionName;

struct InteractionDefinition;

struct IntegerLiteral;

struct Identifier;

struct FunctionName;

struct FloatLiteral;

struct Literal;

struct FileXRefs;

struct File;

enum class FieldKind;

struct FieldSpecification;

struct StructType;

struct UnqualField;

struct UnionType;

struct FieldDecl;

struct ExceptionVal;

struct ExceptionType;

struct ExceptionSpecName;

struct ExceptionSpecification;

struct ResultStream;

struct TypeDefException;

struct ExceptionName;

struct EnumerationType;

struct EnumValueDef;

struct EnumValue;

struct EnumVal;

struct DeclarationComment;

struct DeclarationFile;

struct DeclarationMember;

struct DeclarationName;

struct DeclarationNameSpan;

struct DeclarationUses;

struct FileDeclaration;

struct FunctionDeclarationName;

} // namespace Fbthrift

namespace Hack {

struct HackToThrift;

struct ThriftToHack;

} // namespace Hack

namespace Fbthrift {

struct ContainerType;

struct TypeSpecification;

struct ConstantDefinition;

struct Constant;

} // namespace Fbthrift

namespace Erlang {

struct NameLowerCase;

struct Fqn;

struct FunctionDeclaration;

struct XRefViaFqn;

struct XRefsViaFqnByFile;

struct DeclarationComment;

struct Declaration;

struct DeclarationLocation;

struct DeclarationReference;

struct DeclarationToFqn;

struct DeclarationUses;

struct DeclarationWithFqn;

struct DeclarationsByFile;

struct SearchByName;

} // namespace Erlang

namespace Dyn {

enum class Usage;

struct ObserverIdentifier;

struct Observer;

struct Environment;

struct EntityDynamicReference;

} // namespace Dyn

namespace Digest {

struct Digest;

struct FileDigest;

} // namespace Digest

namespace Glass {

struct FileMetadata;

struct FileInfo;

} // namespace Glass

namespace Dataswarm {

struct TableDeclaration;

struct TableColumnDeclaration;

struct SubqueryDeclaration;

struct SubqueryColumnDeclaration;

struct MacroDeclaration;

struct Declaration;

struct DeclarationLocation;

struct DeclarationName;

struct XRef;

struct XRefsByFile;

} // namespace Dataswarm

namespace Cxx1 {

struct XRefVia;

struct VariableLowerCase;

struct UsingDirective;

struct UsingDeclaration;

struct TypeAliasLowerCase;

enum class TypeAliasKind;

struct TypeAliasDeclaration;

struct Type;

struct TranslationUnitXRefs;

struct TranslationUnitTrace;

struct TranslationUnitIncludeTree;

struct Trace;

enum class RefQualifier;

struct RecordUnionLowerCase;

struct RecordStructLowerCase;

struct RecordDerived;

struct RecordClassLowerCase;

struct PpEntity;

struct Parameter;

struct Signature;

struct PPDefineLocation;

struct ObjcSelectorSlot;

struct ObjcSelector;

enum class ObjcPropertyKind;

struct ObjcPropertyImplementation;

struct ObjcPropertyIVar;

struct ObjcMethodDefinition;

struct ObjcMethodDeclarationName;

struct ObjcInterfaceToImplementation;

struct ObjcImplements;

struct ObjcIVar;

struct ObjcContainerInterfaceLowerCase;

struct ObjcContainerInheritance;

struct ObjcContainerDefinition;

struct ObjcContainerDeclarationInterface;

struct ObjcContainerBase;

struct ObjcCategoryId;

struct ObjcContainerId;

struct ObjcContainerDeclaration;

struct ObjcMethodDeclaration;

struct ObjcPropertyDeclaration;

struct ObjContainerIdName;

struct NamespaceTarget;

struct NamespaceQName;

struct NamespaceLowerCase;

struct NamespaceDefinition;

struct NamespaceDeclarationName;

struct NamespaceDeclarationByName;

struct NamespaceDeclaration;

struct NamespaceAliasDeclaration;

struct Name;

struct MethodSignature;

struct MethodOverrides;

struct MethodOverridden;

struct MaybeIncludeTree;

enum class LocalVariableKind;

enum class LocalVariableAttribute;

struct LocalVariable;

struct IncludeTreeTranslationUnit;

struct IncludeTreeParent;

struct IncludeTree;

struct IncludeTrace;

struct PPEvent;

struct PPTrace;

enum class GlobalVariableKind;

enum class GlobalVariableAttribute;

struct GlobalVariable;

struct FunctionLowerCase;

struct FunctionDefinition;

struct FunctionDeclarationNameString;

struct FunctionDeclarationName;

struct FunctionDeclaration;

struct FunctionDeclAttribute;

struct FunctionAttribute;

struct From;

struct FileXRefs;

struct FilePPUseXRefs;

struct FilePPUseTraceXRefs;

struct FilePPTraceXRefs;

struct Field;

struct VariableKind;

struct VariableDeclaration;

struct EnumeratorLowerCase;

struct EnumeratorInEnum;

struct EnumeratorByName;

struct Enumerator;

struct EnumLowerCase;

struct EnumDefinition;

struct EnumDeclaration;

struct DefinitionEntity;

struct DefnInRecord;

struct Declaration;

struct DeclarationComment;

struct DeclarationInTrace;

struct DeclarationLocationName;

struct DeclarationLocationNameSpan;

struct DeclarationNameSpan;

struct DeclarationSources;

struct DeclarationSrcRange;

struct DeclarationTargets;

struct DeclarationToUSR;

struct Declarations;

struct DefToBaseDecl;

struct MangledNameHashToDeclaration;

struct Same;

struct USRToDeclaration;

struct XRefTarget;

struct FixedXRef;

struct FileXRefMap;

struct SpellingXRef;

struct TargetUses;

struct ThriftToCxx;

struct XRefIndirectTarget;

struct XRefTargets;

} // namespace Cxx1

namespace Symbolid {

namespace Cxx {

struct LookupNamespaceDeclaration;

} // namespace Cxx

} // namespace Symbolid

namespace Cxx1 {

struct DeclToFamily;

struct DeclInRecord;

struct DeclInObjcContainer;

struct DeclFamilyOf;

struct DeclFamily;

struct CxxToThrift;

struct Attribute;

enum class Access;

struct RecordBase;

struct RecordDefinition;

} // namespace Cxx1

namespace Csharp {

enum class Variance;

enum class UnityPackageType;

struct UnityPackageToProject;

struct UnityPackage;

enum class UnityAssemblyType;

struct UnityProjectSource;

struct TypeParameter;

struct SourceFileToProject;

struct SolutionToProject;

struct Solution;

enum class RefKind;

struct ProjectToSourceFile;

struct ProjectToSolution;

struct ProjectSource;

struct Project;

struct Namespace;

struct NamedType;

struct NameLowerCase;

struct Name;

enum class MethodKind;

struct MethodInvocationExpression;

struct MemberAccessExpression;

struct MSBuildProjectSource;

struct Location;

struct MemberAccessLocation;

struct MethodInvocationLocation;

struct Implements;

struct FunctionPointerType;

struct FullName;

enum class Accessibility;

struct Class;

struct Interface;

struct Record;

struct Struct;

struct AType;

struct ArrayType;

struct Definition;

struct DefinitionLocation;

struct DefinitionLocationName;

struct FileDefinitions;

struct FileEntityXRefs;

struct SearchByName;

struct Field;

struct Local;

struct Method;

struct ObjectCreationLocation;

struct Parameter;

struct PointerType;

struct Property;

struct TypeLocation;

} // namespace Csharp

namespace Codemarkup {

namespace Yaml {

struct YamlDataAvailable;

} // namespace Yaml

namespace Types {

enum class Visibility;

enum class SymbolKind;

} // namespace Types

} // namespace Codemarkup

namespace Search {

namespace Code {

struct CxxNameLowerCase;

struct FlowNameLowerCase;

struct HackNameLowerCase;

struct PythonNameLowerCase;

} // namespace Code

} // namespace Search

namespace Codemarkup {

namespace Types {

struct SymbolInfo;

struct RangeSpan;

struct RangeSpanContains;

struct Modifiers;

enum class Modifier;

struct Location;

struct XRefLocation;

} // namespace Types

namespace Search {

enum class SearchCase;

} // namespace Search

namespace Scip {

struct LsifKindToKind;

struct FileXLangSymbolRefs;

} // namespace Scip

namespace Python {

struct NonImportPythonDeclarationKind;

struct NonImportPythonDeclarationInfo;

struct ConvertLabel;

} // namespace Python

namespace Pp {

struct PpIncludeXRefLocations;

} // namespace Pp

namespace Lsif {

struct LsifKindToKind;

} // namespace Lsif

namespace Hack {

enum class RequiredRelation;

struct HackInheritedEntities;

struct HackEnumInheritedMembers;

struct FromHackVisibility;

} // namespace Hack

namespace Flow {

struct FlowDocumentationSpan;

struct FlowDeclarationDocumentation;

} // namespace Flow

namespace Cxx {

struct FromCxxVisibility;

struct CxxFileEntityXMapVariableXRefDeclLocations;

struct CxxDeclarationModifiers;

struct CxxDeclVisibility;

struct CxxDeclKind;

struct CxxDeclInfo;

struct CxxDataAvailable;

} // namespace Cxx

enum class SearchStyle;

enum class RelationType;

struct IndexedFile;

struct EntityDataAvailable;

} // namespace Codemarkup

namespace Code {

namespace Scip {

struct Entity;

} // namespace Scip

} // namespace Code

namespace Codemarkup {

namespace Scip {

struct EntityInfo;

struct ScipEntityDocumentation;

struct ScipEntityLocation;

struct ScipEntityUses;

struct ScipFileEntityXRefLocations;

struct ScipResolveLocation;

} // namespace Scip

} // namespace Codemarkup

namespace Code {

namespace Python {

struct Entity;

} // namespace Python

} // namespace Code

namespace Codemarkup {

namespace Python {

struct PythonContainsChildEntity;

struct PythonContainsParentEntity;

struct PythonEntityComments;

struct PythonEntityInfo;

struct PythonEntityKind;

struct PythonEntityLocation;

struct PythonEntityModuleName;

struct PythonEntityUses;

struct PythonExtendsChildEntity;

struct PythonExtendsParentEntity;

struct PythonFileEntityXRefLocations;

struct PythonModifiers;

struct PythonResolveLocation;

struct PythonVisibility;

} // namespace Python

} // namespace Codemarkup

namespace Code {

namespace Python {

struct Annotations;

} // namespace Python

} // namespace Code

namespace Codemarkup {

namespace Python {

struct PythonAnnotation;

} // namespace Python

} // namespace Codemarkup

namespace Code {

namespace Pp {

struct Entity;

} // namespace Pp

} // namespace Code

namespace Codemarkup {

namespace Pp {

struct PPEntityLocation;

struct PpEntityInfo;

struct PpEntityKind;

struct PpEntityTraceXRefLocations;

struct PpEntityUses;

struct PpFileEntityXRefLocations;

struct PpResolveLocation;

struct PpResolveTraceLocation;

} // namespace Pp

} // namespace Codemarkup

namespace Code {

namespace Lsif {

struct Entity;

} // namespace Lsif

} // namespace Code

namespace Codemarkup {

namespace Lsif {

struct EntityInfo;

struct LsifEntityLocation;

struct LsifEntityModuleName;

struct LsifEntityUses;

struct LsifFileEntityXRefLocations;

struct LsifResolveLocation;

} // namespace Lsif

} // namespace Codemarkup

namespace Code {

namespace Kotlin {

struct Entity;

} // namespace Kotlin

} // namespace Code

namespace Codemarkup {

namespace Kotlin {

struct KotlinContainsChildEntity;

struct KotlinContainsParentEntity;

struct KotlinEntityKind;

struct KotlinEntityLocation;

struct KotlinEntityUses;

struct KotlinExtendsParentEntity;

struct KotlinFileEntityXRefLocations;

struct KotlinResolveLocation;

} // namespace Kotlin

} // namespace Codemarkup

namespace Code {

namespace Java {

struct Entity;

} // namespace Java

} // namespace Code

namespace Codemarkup {

namespace Java {

struct JavaContainsChildEntity;

struct JavaContainsParentEntity;

struct JavaEntityDocumentation;

struct JavaEntityKind;

struct JavaEntityLocation;

struct JavaEntityUses;

struct JavaExtendsChildEntity;

struct JavaExtendsParentEntity;

struct JavaModifiers;

struct JavaResolveLocation;

struct JavaVisibility;

struct JavalFileEntityXRefLocations;

} // namespace Java

} // namespace Codemarkup

namespace Code {

namespace Java {

struct Annotations;

} // namespace Java

} // namespace Code

namespace Codemarkup {

namespace Java {

struct JavaAnnotation;

} // namespace Java

} // namespace Codemarkup

namespace Code {

namespace Hs {

struct Entity;

} // namespace Hs

} // namespace Code

namespace Codemarkup {

namespace Haskell {

struct HaskellContainsChildEntity;

struct HaskellContainsParentEntity;

struct HaskellEntityLocation;

struct HaskellEntityUses;

struct HaskellFileEntityXRefLocations;

struct HaskellResolveLocation;

} // namespace Haskell

} // namespace Codemarkup

namespace Search {

namespace Hs {

struct SearchByLowerCaseName;

struct SearchByName;

} // namespace Hs

} // namespace Search

namespace Code {

namespace Hack {

struct Entity;

} // namespace Hack

} // namespace Code

namespace Codemarkup {

namespace Hack {

struct EntityHasHideFromDocsAttr;

struct HackContainsChildEntity;

struct HackContainsParentEntity;

struct HackEntityDocumentation;

struct HackEntityInfo;

struct HackEntityKind;

struct HackEntityLocation;

struct HackEntityModuleName;

struct HackEntitySource;

struct HackEntityUses;

struct HackExtendsChildEntity;

struct HackExtendsParentEntity;

struct HackExtendsParentEntityConcise;

struct HackFileEntityXRefLocations;

struct HackFileEntityXRefSpans;

struct HackModifiers;

struct HackRequiredConstraint;

struct HackResolveLocation;

struct HackVisibility;

} // namespace Hack

} // namespace Codemarkup

namespace Code {

namespace Hack {

struct Annotations;

} // namespace Hack

} // namespace Code

namespace Codemarkup {

namespace Hack {

struct HackAnnotation;

} // namespace Hack

} // namespace Codemarkup

namespace Code {

namespace Graphql {

struct Entity;

} // namespace Graphql

} // namespace Code

namespace Codemarkup {

namespace Graphql {

struct GraphQLEntityKind;

struct GraphQLEntityLocation;

struct GraphQLEntityUses;

struct GraphQLFileEntityXRefLocations;

struct GraphQLResolveLocation;

} // namespace Graphql

} // namespace Codemarkup

namespace Code {

namespace Flow {

struct Entity;

} // namespace Flow

} // namespace Code

namespace Codemarkup {

namespace Flow {

struct FlowContainsChildEntity;

struct FlowContainsParentEntity;

struct FlowEntityDocumentation;

struct FlowEntityKind;

struct FlowEntityLocation;

struct FlowEntityModuleName;

struct FlowEntityUses;

struct FlowFileEntityXRefLocations;

struct FlowFileImportDeclEntityXRefLocations;

struct FlowFileReferenceEntityXRefLocations;

struct FlowResolveLocation;

} // namespace Flow

} // namespace Codemarkup

namespace Code {

namespace Fbthrift {

struct Entity;

} // namespace Fbthrift

} // namespace Code

namespace Codemarkup {

namespace Fbthrift {

struct FbthriftEntityDocumentation;

struct FbthriftEntityUses;

struct ThriftContainsChildEntity;

struct ThriftContainsParentEntity;

struct ThriftEntityKind;

struct ThriftEntityLocation;

struct ThriftExtendsChildEntity;

struct ThriftExtendsParentEntity;

struct ThriftFileEntityXRefLocations;

struct ThriftResolveLocation;

} // namespace Fbthrift

} // namespace Codemarkup

namespace Code {

namespace Fbthrift {

struct Annotations;

} // namespace Fbthrift

namespace Erlang {

struct Entity;

} // namespace Erlang

} // namespace Code

namespace Codemarkup {

namespace Erlang {

struct ErlangEntityDocumentation;

struct ErlangEntityInfo;

struct ErlangEntityKind;

struct ErlangEntityLocation;

struct ErlangEntityUses;

struct ErlangFileEntityXRefLocations;

struct ErlangResolveLocation;

} // namespace Erlang

} // namespace Codemarkup

namespace Search {

namespace Erlang {

struct SearchByFQN;

struct SearchByName;

} // namespace Erlang

} // namespace Search

namespace Code {

namespace Dataswarm {

struct Entity;

} // namespace Dataswarm

} // namespace Code

namespace Codemarkup {

namespace Dataswarm {

struct DataswarmFileEntityXRefLocations;

} // namespace Dataswarm

} // namespace Codemarkup

namespace Code {

namespace Cxx {

struct ObjcMethodEntity;

struct ObjcSelectorSlotEntity;

struct Definition;

struct Entity;

} // namespace Cxx

} // namespace Code

namespace Codemarkup {

namespace Cxx {

struct CxxContainsChildEntity;

struct CxxContainsParentEntity;

struct CxxDeclToDefXRefTargetLocation;

struct CxxDeclarationContainsChild;

struct CxxDeclarationContainsParent;

struct CxxDeclarationExtendsChild;

struct CxxDeclarationExtendsParent;

struct CxxDeclarationSource;

struct CxxDefToDeclFamilyXRefTargetLocation;

struct CxxEntityDocumentation;

struct CxxEntityInfo;

struct CxxEntityKind;

struct CxxEntityLocation;

struct CxxEntityMangledNameHash;

struct CxxEntitySource;

struct CxxEntityUSR;

struct CxxEntityUses;

struct CxxExtendsChildEntity;

struct CxxExtendsParentEntity;

struct CxxFileEntitySpellingXRefLocations;

struct CxxFileEntityTraceDeclToDefXRefLocations;

struct CxxFileEntityXMapFixedXRefLocations;

struct CxxFileEntityXMapVariableXRefDeclToDefs;

struct CxxFileEntityXRefLocations;

struct CxxFindDefinitionOfEntity;

struct CxxModifiers;

struct CxxNamespaceDeclarationContainsChild;

struct CxxResolveDeclarationToEntity;

struct CxxResolveLocation;

struct CxxResolveTraceLocation;

struct CxxVisibility;

struct CxxXRefTargetLocation;

struct EntityToXRefTarget;

struct SymbolToEntity;

struct XRefTargetToEntity;

} // namespace Cxx

} // namespace Codemarkup

namespace Glean {

namespace Test {

struct Entity;

} // namespace Test

} // namespace Glean

namespace Search {

namespace Code {

struct CxxPreferDefinitions;

} // namespace Code

namespace Kind {

namespace Cxx {

struct SearchObjcInterface;

} // namespace Cxx

} // namespace Kind

} // namespace Search

namespace Symbolid {

namespace Cxx {

struct DefinitionOfDecl;

struct LookupNamespaceDefinition;

} // namespace Cxx

} // namespace Symbolid

namespace Codemarkup {

namespace Cxx {

struct CxxDefinitionContainsChild;

struct CxxDefinitionContainsParent;

struct CxxDefinitionExtendsChild;

struct CxxDefinitionExtendsParent;

struct CxxDefinitionModifiers;

struct CxxDefnVisibility;

struct CxxEntityDefinitionBase;

} // namespace Cxx

} // namespace Codemarkup

namespace Search {

namespace Cxx {

struct DeclIsDefn;

} // namespace Cxx

} // namespace Search

namespace Code {

namespace Cxx {

struct DeclToDef;

struct Annotations;

} // namespace Cxx

} // namespace Code

namespace Codemarkup {

namespace Cxx {

struct CxxAnnotation;

} // namespace Cxx

} // namespace Codemarkup

namespace Code {

namespace Csharp {

struct Entity;

} // namespace Csharp

} // namespace Code

namespace Codemarkup {

namespace Csharp {

struct CSharpEntityKind;

struct CSharpEntityLocation;

struct CSharpEntityUses;

struct CSharpFileEntityXRefLocations;

struct CSharpResolveLocation;

} // namespace Csharp

} // namespace Codemarkup

namespace Code {

namespace Buck {

struct Entity;

} // namespace Buck

} // namespace Code

namespace Codemarkup {

namespace Buck {

struct BuckEntityKind;

struct BuckEntityLocation;

struct BuckEntityUses;

struct BuckFileEntityXRefLocations;

struct BuckResolveLocation;

} // namespace Buck

} // namespace Codemarkup

namespace Search {

namespace Buck {

struct SearchByFQN;

struct SearchDefinition;

struct SearchFile;

} // namespace Buck

} // namespace Search

namespace Code {

struct SymbolId;

enum class Language;

struct EntityLanguageSCIP;

struct EntityLanguageLSIF;

struct Annotations;

} // namespace Code

namespace Cxx1 {

struct FunctionName;

struct RecordKind;

struct RecordDeclaration;

struct Scope;

struct DeclarationScope;

struct EnumDeclarationByName;

struct FunctionDeclarationByNameScope;

struct FunctionQName;

struct QName;

struct RecordDeclarationClass;

struct RecordDeclarationStruct;

struct RecordDeclarationUnion;

struct TypeAliasDeclarationByName;

struct VariableDeclarationNonLocalByName;

} // namespace Cxx1

namespace Search {

namespace Cxx {

struct QueryToScopeCase;

} // namespace Cxx

namespace Kind {

namespace Cxx {

struct SearchClass;

struct SearchEnum;

struct SearchEnumerator;

struct SearchFunction;

struct SearchNamespace;

struct SearchStruct;

struct SearchTypeAlias;

struct SearchUnion;

struct SearchVariable;

} // namespace Cxx

} // namespace Kind

} // namespace Search

namespace Symbolid {

namespace Cxx {

struct LookupDeclaration;

struct LookupDefinition;

struct LookupEnumerator;

struct LookupFunctionDeclaration;

struct LookupFunctionDefinition;

struct LookupFunctionSignatureDeclaration;

struct LookupFunctionSignatureDefinition;

struct LookupFunctionSignatureQualifierDeclaration;

struct LookupFunctionSignatureQualifierDefinition;

} // namespace Cxx

} // namespace Symbolid

namespace Fbthrift {

struct ResultType;

struct FunctionSpecification;

} // namespace Fbthrift

namespace Buck {

struct XRefDestination;

struct XRef;

struct Type;

struct TranslationUnit;

struct TargetUses;

struct TargetSourcesBaseModule;

struct TargetSources;

struct TargetOuts;

struct TargetOut;

struct TargetMode;

struct TargetLocation;

struct TargetLinkWhole;

struct TargetIndexerName;

struct TargetIndexer;

struct TargetHash;

struct TargetCallByCallExpr;

struct TargetCall;

struct TargetByType;

struct TargetAttribute;

struct Target;

struct SourceFileLocation;

struct SearchByLocalName;

struct RuleKey;

struct Platform;

struct Owner;

struct OutsTarget;

struct OutputLabel;

struct OutTarget;

struct LocatorWithLabel;

struct LocatorReverseDeps;

struct LocatorReverseDep;

struct Locator;

struct LocalNameLowerCase;

struct LocalName;

struct Labels;

struct Label;

struct IndexerName;

struct FileXRefs;

struct FileToTarget;

struct FileTarget;

struct FileResolved;

struct FileEntity;

struct FileDefinition;

struct File;

struct FailureSources;

enum class FailureReason;

struct IndexFailureX;

struct DestinationUses;

struct Dependency;

struct TargetDependencies;

struct DefinitionLocation;

struct Definition;

struct Consumer;

struct CallName;

struct CallExpr;

struct CallArgument;

struct AttributeName;

struct AttributeMapping;

struct AttributeValue;

struct ArgumentMapping;

struct ArgumentValue;

} // namespace Buck

namespace Anglelang {

struct TypeDecl;

struct Name;

struct Field;

struct Type;

struct EvolveDecl;

enum class DeriveInfo;

struct DerivingDecl;

struct PredicateDecl;

struct Declaration;

struct DeclarationLocation;

struct DeclarationToName;

struct SchemaDecl;

struct XRefTarget;

struct TargetUses;

struct XRef;

struct FileXRefs;

} // namespace Anglelang

namespace Code {

namespace Anglelang {

struct Entity;

} // namespace Anglelang

struct Entity;

struct Argument;

struct CallArgument;

} // namespace Code

namespace Codemarkup {

namespace Hack {

struct ConvertCallArguments;

struct ConvertMaybeCallArguments;

} // namespace Hack

namespace Python {

struct ConvertCallArguments;

struct PythonFileCall;

} // namespace Python

namespace Hack {

struct ConvertArgument;

} // namespace Hack

namespace Python {

struct ConvertArgument;

} // namespace Python

} // namespace Codemarkup

namespace Code {

struct EntityLanguage;

struct IdlEntity;

} // namespace Code

namespace Codemarkup {

namespace Cxx {

struct CxxEntityIdl;

} // namespace Cxx

namespace Hack {

struct HackEntityIdl;

} // namespace Hack

namespace Yaml {

struct YamlFileEntityXLangXRefLocations;

} // namespace Yaml

struct ChildEntity;

struct ContainsChildEntity;

struct ContainsParentEntity;

struct EntityComments;

struct EntityInfo;

struct EntityIsDefinition;

struct EntityKind;

struct EntityLocation;

struct EntityModifiers;

struct EntityModuleName;

struct EntityReferences;

struct EntitySource;

struct EntityToAnnotations;

struct EntityUses;

struct EntityVisibility;

struct ExtendsChildEntity;

struct ExtendsParentEntity;

struct ExtendsParentEntityConcise;

struct FileCall;

struct FileEntityDigest;

struct FileEntityInfos;

struct FileEntityKinds;

struct FileEntityLocations;

struct FileEntityXRefInfos;

struct FileEntityXRefKinds;

struct FileEntityXRefLocations;

struct FileEntityXRefRangeSpans;

struct FindEntityDefinition;

struct GeneratedEntityToIdlEntity;

struct GenericEntity;

struct FileXRefsGenericEntities;

struct ParentEntity;

struct SearchRelatedEntities;

struct ReferencingEntity;

struct ResolveLocation;

struct SearchInheritedEntities;

struct SymbolToEntity;

namespace Cxx {

struct CxxFileEntityIdl;

struct CxxIdlEntityUses;

} // namespace Cxx

namespace Hack {

struct ConvertCallee;

struct ConvertCalleeForFileCall;

struct ConvertStaticType;

struct HackFileCall;

struct HackIdlEntityUses;

} // namespace Hack

namespace Search {

struct EntityLocationAndKind;

struct SearchByName;

struct SearchByScope;

} // namespace Search

} // namespace Codemarkup

namespace Dyn {

struct EntityUsage;

} // namespace Dyn

namespace Search {

namespace Code {

struct AngleSearchByLowerCaseName;

struct AngleSearchByName;

struct BuckSearchByLocalNameFact;

struct BuckSearchByLowerCaseName;

struct BuckSearchByName;

struct CSharpSearchByLowerCaseName;

struct CSharpSearchByName;

struct CxxSearchByLowerCaseNameKindAndScopeFact;

struct CxxSearchByLowerCaseScopeAndKind;

struct CxxSearchByNameKindAndScopeFact;

struct CxxSearchByScopeAndKind;

struct ErlangSearchByLowerCaseName;

struct ErlangSearchByName;

struct FbthriftSearchByNameFact;

struct FlowSearchByLowerCaseNameKindAndScopeFact;

struct FlowSearchByLowerCaseScopeAndKind;

struct FlowSearchByNameKindAndScopeFact;

struct FlowSearchByScopeAndKind;

struct GraphQLSearchByLowerCaseName;

struct GraphQLSearchByName;

struct HackSearchByLowerCaseNameAndKind;

struct HackSearchByLowerCaseScopeAndKind;

struct HackSearchByNameAndKind;

struct HackSearchByNameKindWithNamespace;

struct HackSearchByNameKindWithQName;

struct HackSearchByScopeAndKind;

struct HackSearchByScopeWithNameKinds;

struct HsSearchByLowerCaseName;

struct HsSearchByName;

struct JavaSearchByLowerCaseName;

struct JavaSearchByLowerCaseScope;

struct JavaSearchByName;

struct JavaSearchByNameWithFact;

struct JavaSearchByScope;

struct JavaSearchByScopeWithName;

struct KotlinSearchByLowerCaseName;

struct KotlinSearchByLowerCaseScope;

struct KotlinSearchByName;

struct KotlinSearchByNameWithFact;

struct KotlinSearchByScope;

struct KotlinSearchByScopeWithName;

struct LsifSearchByLowerCaseName;

struct LsifSearchByName;

struct PpSearchByLowerCaseNameKind;

struct PpSearchByNameKind;

struct PythonSearchByLowerCaseNameKindAndScopeFact;

struct PythonSearchByLowerCaseScopeAndKind;

struct PythonSearchByNameKindAndScopeFact;

struct PythonSearchByScopeAndKind;

struct RustSearchByNameAndKind;

struct SearchByLowerCaseNameAndLanguage;

struct SearchByLowerCaseNameKindAndLanguage;

struct SearchByLowerCaseScope;

struct SearchByLowerCaseScopeAndKind;

struct SearchByNameAndLanguage;

struct SearchByNameKindAndLanguage;

struct SearchByScope;

struct SearchByScopeAndKind;

struct ThriftSearchByLowerCaseName;

struct ThriftSearchByName;

} // namespace Code

} // namespace Search

namespace Codemarkup {

namespace Anglelang {

struct AngleEntityLocation;

struct AngleEntityUses;

struct AngleFileEntityXRefLocations;

struct AngleResolveLocation;

} // namespace Anglelang

} // namespace Codemarkup

namespace Search {

namespace Anglelang {

struct SearchByName;

} // namespace Anglelang

} // namespace Search

namespace Sys {

struct Blob : Predicate<std::vector<uint8_t>> {
  static const char* GLEAN_name() {
    return "sys.Blob";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Blob

} // namespace Sys

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Src::RelByteSpan> {
  using Type = Tuple<Nat, Nat>;
};


namespace schema {

namespace Src {

struct RelByteSpan {
  uint64_t offset;
  uint64_t length;

  bool operator==(const RelByteSpan& other) const {
    return std::tie(offset,length)
             == std::tie(other.offset,other.length);
  }
  bool operator!=(const RelByteSpan& other) const {
    return std::tie(offset,length)
             != std::tie(other.offset,other.length);
  }
  bool operator<(const RelByteSpan& other) const {
    return std::tie(offset,length)
             < std::tie(other.offset,other.length);
  }
  bool operator<=(const RelByteSpan& other) const {
    return std::tie(offset,length)
             <= std::tie(other.offset,other.length);
  }
  bool operator>(const RelByteSpan& other) const {
    return std::tie(offset,length)
             > std::tie(other.offset,other.length);
  }
  bool operator>=(const RelByteSpan& other) const {
    return std::tie(offset,length)
             >= std::tie(other.offset,other.length);
  }
  void outputRepr(Output<Repr<RelByteSpan>> out) const {
    outputValue(out, std::make_tuple(offset, length));
  }
}; // struct RelByteSpan

} // namespace Src

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Src::Range> {
  using Type = Tuple<facebook::glean::cpp::schema::Src::File, Nat, Nat, Nat, Nat>;
};


namespace schema {

namespace Src {

struct Range {
  Fact<File> file;
  uint64_t lineBegin;
  uint64_t columnBegin;
  uint64_t lineEnd;
  uint64_t columnEnd;

  bool operator==(const Range& other) const {
    return std::tie(file,lineBegin,columnBegin,lineEnd,columnEnd)
             == std::tie(other.file,other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  bool operator!=(const Range& other) const {
    return std::tie(file,lineBegin,columnBegin,lineEnd,columnEnd)
             != std::tie(other.file,other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  bool operator<(const Range& other) const {
    return std::tie(file,lineBegin,columnBegin,lineEnd,columnEnd)
             < std::tie(other.file,other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  bool operator<=(const Range& other) const {
    return std::tie(file,lineBegin,columnBegin,lineEnd,columnEnd)
             <= std::tie(other.file,other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  bool operator>(const Range& other) const {
    return std::tie(file,lineBegin,columnBegin,lineEnd,columnEnd)
             > std::tie(other.file,other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  bool operator>=(const Range& other) const {
    return std::tie(file,lineBegin,columnBegin,lineEnd,columnEnd)
             >= std::tie(other.file,other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  void outputRepr(Output<Repr<Range>> out) const {
    outputValue(out, std::make_tuple(file, lineBegin, columnBegin, lineEnd, columnEnd));
  }
}; // struct Range

struct RangeContains : Predicate<std::tuple<Range, Range>> {
  static const char* GLEAN_name() {
    return "src.RangeContains";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct RangeContains

} // namespace Src

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Src::PackedByteSpansGroup> {
  using Type = Tuple<Nat, Array<Nat>>;
};


namespace schema {

namespace Src {

struct PackedByteSpansGroup {
  uint64_t length;
  std::vector<uint64_t> offsets;

  bool operator==(const PackedByteSpansGroup& other) const {
    return std::tie(length,offsets)
             == std::tie(other.length,other.offsets);
  }
  bool operator!=(const PackedByteSpansGroup& other) const {
    return std::tie(length,offsets)
             != std::tie(other.length,other.offsets);
  }
  bool operator<(const PackedByteSpansGroup& other) const {
    return std::tie(length,offsets)
             < std::tie(other.length,other.offsets);
  }
  bool operator<=(const PackedByteSpansGroup& other) const {
    return std::tie(length,offsets)
             <= std::tie(other.length,other.offsets);
  }
  bool operator>(const PackedByteSpansGroup& other) const {
    return std::tie(length,offsets)
             > std::tie(other.length,other.offsets);
  }
  bool operator>=(const PackedByteSpansGroup& other) const {
    return std::tie(length,offsets)
             >= std::tie(other.length,other.offsets);
  }
  void outputRepr(Output<Repr<PackedByteSpansGroup>> out) const {
    outputValue(out, std::make_tuple(length, offsets));
  }
}; // struct PackedByteSpansGroup

using PackedByteSpans = std::vector<PackedByteSpansGroup>;

} // namespace Src

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Src::Loc> {
  using Type = Tuple<facebook::glean::cpp::schema::Src::File, Nat, Nat>;
};


namespace schema {

namespace Src {

struct Loc {
  Fact<File> file;
  uint64_t line;
  uint64_t column;

  bool operator==(const Loc& other) const {
    return std::tie(file,line,column)
             == std::tie(other.file,other.line,other.column);
  }
  bool operator!=(const Loc& other) const {
    return std::tie(file,line,column)
             != std::tie(other.file,other.line,other.column);
  }
  bool operator<(const Loc& other) const {
    return std::tie(file,line,column)
             < std::tie(other.file,other.line,other.column);
  }
  bool operator<=(const Loc& other) const {
    return std::tie(file,line,column)
             <= std::tie(other.file,other.line,other.column);
  }
  bool operator>(const Loc& other) const {
    return std::tie(file,line,column)
             > std::tie(other.file,other.line,other.column);
  }
  bool operator>=(const Loc& other) const {
    return std::tie(file,line,column)
             >= std::tie(other.file,other.line,other.column);
  }
  void outputRepr(Output<Repr<Loc>> out) const {
    outputValue(out, std::make_tuple(file, line, column));
  }
}; // struct Loc

} // namespace Src

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Src::Language> {
  using Type = Enum<11>;
};


namespace schema {

namespace Src {

enum class Language { Buck, C, Cpp, Hack, Haskell, ObjC, ObjCpp, Python, Thrift, Java, GraphQL };

} // namespace Src

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Src::IndexFailureReason> {
  using Type = Enum<4>;
};


namespace schema {

namespace Src {

enum class IndexFailureReason { CompileError, BuildSystemError, Unclassified, DiscoveryError };

struct IndexFailure : Predicate<std::tuple<Fact<File>, IndexFailureReason, std::string>> {
  static const char* GLEAN_name() {
    return "src.IndexFailure";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct IndexFailure

struct FileLines : Predicate<std::tuple<Fact<File>, std::vector<uint64_t>, bool, bool>> {
  static const char* GLEAN_name() {
    return "src.FileLines";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileLines

struct FileLanguage : Predicate<std::tuple<Fact<File>, Language>> {
  static const char* GLEAN_name() {
    return "src.FileLanguage";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileLanguage

struct FileDigest : Predicate<Fact<File>, std::string> {
  static const char* GLEAN_name() {
    return "src.FileDigest";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileDigest

struct File : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "src.File";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct File

} // namespace Src

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Src::ByteSpan> {
  using Type = Tuple<Nat, Nat>;
};


namespace schema {

namespace Src {

struct ByteSpan {
  uint64_t start;
  uint64_t length;

  bool operator==(const ByteSpan& other) const {
    return std::tie(start,length)
             == std::tie(other.start,other.length);
  }
  bool operator!=(const ByteSpan& other) const {
    return std::tie(start,length)
             != std::tie(other.start,other.length);
  }
  bool operator<(const ByteSpan& other) const {
    return std::tie(start,length)
             < std::tie(other.start,other.length);
  }
  bool operator<=(const ByteSpan& other) const {
    return std::tie(start,length)
             <= std::tie(other.start,other.length);
  }
  bool operator>(const ByteSpan& other) const {
    return std::tie(start,length)
             > std::tie(other.start,other.length);
  }
  bool operator>=(const ByteSpan& other) const {
    return std::tie(start,length)
             >= std::tie(other.start,other.length);
  }
  void outputRepr(Output<Repr<ByteSpan>> out) const {
    outputValue(out, std::make_tuple(start, length));
  }
}; // struct ByteSpan

struct ByteSpanContains : Predicate<std::tuple<ByteSpan, ByteSpan>> {
  static const char* GLEAN_name() {
    return "src.ByteSpanContains";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ByteSpanContains

} // namespace Src

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Src::FileLocation> {
  using Type = Tuple<facebook::glean::cpp::schema::Src::File, Repr<facebook::glean::cpp::schema::Src::ByteSpan>>;
};


namespace schema {

namespace Src {

struct FileLocation {
  Fact<File> file;
  ByteSpan span;

  bool operator==(const FileLocation& other) const {
    return std::tie(file,span)
             == std::tie(other.file,other.span);
  }
  bool operator!=(const FileLocation& other) const {
    return std::tie(file,span)
             != std::tie(other.file,other.span);
  }
  bool operator<(const FileLocation& other) const {
    return std::tie(file,span)
             < std::tie(other.file,other.span);
  }
  bool operator<=(const FileLocation& other) const {
    return std::tie(file,span)
             <= std::tie(other.file,other.span);
  }
  bool operator>(const FileLocation& other) const {
    return std::tie(file,span)
             > std::tie(other.file,other.span);
  }
  bool operator>=(const FileLocation& other) const {
    return std::tie(file,span)
             >= std::tie(other.file,other.span);
  }
  void outputRepr(Output<Repr<FileLocation>> out) const {
    outputValue(out, std::make_tuple(file, span));
  }
}; // struct FileLocation

} // namespace Src

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Src::ByteRange> {
  using Type = Tuple<Nat, Nat>;
};


namespace schema {

namespace Src {

struct ByteRange {
  uint64_t begin;
  uint64_t end;

  bool operator==(const ByteRange& other) const {
    return std::tie(begin,end)
             == std::tie(other.begin,other.end);
  }
  bool operator!=(const ByteRange& other) const {
    return std::tie(begin,end)
             != std::tie(other.begin,other.end);
  }
  bool operator<(const ByteRange& other) const {
    return std::tie(begin,end)
             < std::tie(other.begin,other.end);
  }
  bool operator<=(const ByteRange& other) const {
    return std::tie(begin,end)
             <= std::tie(other.begin,other.end);
  }
  bool operator>(const ByteRange& other) const {
    return std::tie(begin,end)
             > std::tie(other.begin,other.end);
  }
  bool operator>=(const ByteRange& other) const {
    return std::tie(begin,end)
             >= std::tie(other.begin,other.end);
  }
  void outputRepr(Output<Repr<ByteRange>> out) const {
    outputValue(out, std::make_tuple(begin, end));
  }
}; // struct ByteRange

} // namespace Src

namespace Search {

namespace Python {

struct QueryToScopeCase : Predicate<std::tuple<std::vector<std::string>, bool, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Python::SName>>>>> {
  static const char* GLEAN_name() {
    return "search.python.QueryToScopeCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct QueryToScopeCase

struct PythonNameCase : Predicate<std::tuple<bool, std::string, Fact<facebook::glean::cpp::schema::Python::Name>>> {
  static const char* GLEAN_name() {
    return "search.python.PythonNameCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct PythonNameCase

} // namespace Python

namespace Pp {

struct SearchByName : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Pp1::Macro>, Fact<facebook::glean::cpp::schema::Pp1::Define>>> {
  static const char* GLEAN_name() {
    return "search.pp.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct SearchByName

} // namespace Pp

namespace Java {

struct QueryToScopeCase : Predicate<std::tuple<std::vector<std::string>, bool, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Path>>> {
  static const char* GLEAN_name() {
    return "search.java.QueryToScopeCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct QueryToScopeCase

struct NameCase : Predicate<std::tuple<bool, std::string, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Name>>> {
  static const char* GLEAN_name() {
    return "search.java.NameCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct NameCase

} // namespace Java

namespace Hack {

struct QueryToScopeCase : Predicate<std::tuple<std::vector<std::string>, bool, Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>>> {
  static const char* GLEAN_name() {
    return "search.hack.QueryToScopeCase";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct QueryToScopeCase

struct HackNameCase : Predicate<std::tuple<bool, std::string, Fact<facebook::glean::cpp::schema::Hack::Name>>> {
  static const char* GLEAN_name() {
    return "search.hack.HackNameCase";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct HackNameCase

struct HackInAutoImportedNamespace : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>>> {
  static const char* GLEAN_name() {
    return "search.hack.HackInAutoImportedNamespace";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct HackInAutoImportedNamespace

} // namespace Hack

namespace Flow {

struct TypeDeclarationAsDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Flow::TypeDeclaration>, Fact<facebook::glean::cpp::schema::Flow::Declaration>>> {
  static const char* GLEAN_name() {
    return "search.flow.TypeDeclarationAsDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TypeDeclarationAsDeclaration

struct QueryToScopeCase : Predicate<std::tuple<std::vector<std::string>, bool, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Flow::Module>>>>> {
  static const char* GLEAN_name() {
    return "search.flow.QueryToScopeCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct QueryToScopeCase

struct FlowModuleNameCase : Predicate<std::tuple<bool, std::string, Fact<facebook::glean::cpp::schema::Flow::Module>>> {
  static const char* GLEAN_name() {
    return "search.flow.FlowModuleNameCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FlowModuleNameCase

} // namespace Flow

namespace Cxx {

struct QueryToQNameCase : Predicate<std::tuple<std::vector<std::string>, bool, Fact<facebook::glean::cpp::schema::Cxx1::QName>>> {
  static const char* GLEAN_name() {
    return "search.cxx.QueryToQNameCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct QueryToQNameCase

struct QueryToNSQNameCase : Predicate<std::tuple<std::vector<std::string>, bool, Fact<facebook::glean::cpp::schema::Cxx1::NamespaceQName>>> {
  static const char* GLEAN_name() {
    return "search.cxx.QueryToNSQNameCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct QueryToNSQNameCase

struct CxxRecordCase : Predicate<std::tuple<bool, std::string, Fact<facebook::glean::cpp::schema::Cxx1::Name>>> {
  static const char* GLEAN_name() {
    return "search.cxx.CxxRecordCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct CxxRecordCase

struct CxxNamespaceCase : Predicate<std::tuple<bool, std::string, Fact<facebook::glean::cpp::schema::Cxx1::Name>>> {
  static const char* GLEAN_name() {
    return "search.cxx.CxxNamespaceCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct CxxNamespaceCase

} // namespace Cxx

namespace Anglelang {

struct NameLowerCase : Predicate<std::tuple<std::string, Fact<facebook::glean::cpp::schema::Anglelang::Name>>> {
  static const char* GLEAN_name() {
    return "search.anglelang.NameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct NameLowerCase

} // namespace Anglelang

} // namespace Search

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Scip::TextEncoding> {
  using Type = Enum<3>;
};


namespace schema {

namespace Scip {

enum class TextEncoding { UnspecifiedTextEncoding, UTF8, UTF16 };

struct SymbolName : Predicate<std::tuple<Fact<Symbol>, Fact<LocalName>>> {
  static const char* GLEAN_name() {
    return "scip.SymbolName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SymbolName

struct SymbolDocumentation : Predicate<std::tuple<Fact<Symbol>, Fact<Documentation>>> {
  static const char* GLEAN_name() {
    return "scip.SymbolDocumentation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SymbolDocumentation

struct SymbolDisplayName : Predicate<std::tuple<Fact<Symbol>, Fact<DisplayName>>> {
  static const char* GLEAN_name() {
    return "scip.SymbolDisplayName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SymbolDisplayName

struct Symbol : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "scip.Symbol";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Symbol

} // namespace Scip

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Scip::SomeEntity> {
  using Type = Tuple<facebook::glean::cpp::schema::Scip::Definition>;
};


namespace schema {

namespace Scip {

struct SomeEntity {
  Fact<Definition> defn;

  bool operator==(const SomeEntity& other) const {
    return std::tie(defn)
             == std::tie(other.defn);
  }
  bool operator!=(const SomeEntity& other) const {
    return std::tie(defn)
             != std::tie(other.defn);
  }
  bool operator<(const SomeEntity& other) const {
    return std::tie(defn)
             < std::tie(other.defn);
  }
  bool operator<=(const SomeEntity& other) const {
    return std::tie(defn)
             <= std::tie(other.defn);
  }
  bool operator>(const SomeEntity& other) const {
    return std::tie(defn)
             > std::tie(other.defn);
  }
  bool operator>=(const SomeEntity& other) const {
    return std::tie(defn)
             >= std::tie(other.defn);
  }
  void outputRepr(Output<Repr<SomeEntity>> out) const {
    outputValue(out, std::make_tuple(defn));
  }
}; // struct SomeEntity

struct ReferenceTarget : Predicate<std::tuple<Fact<Reference>, Fact<Definition>>> {
  static const char* GLEAN_name() {
    return "scip.ReferenceTarget";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ReferenceTarget

struct Reference : Predicate<std::tuple<Fact<Symbol>, Fact<FileRange>>> {
  static const char* GLEAN_name() {
    return "scip.Reference";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Reference

} // namespace Scip

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Scip::ProtocolVersion> {
  using Type = Enum<1>;
};


namespace schema {

namespace Scip {

enum class ProtocolVersion { UnspecifiedProtocolVersion };

} // namespace Scip

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Scip::Location> {
  using Type = Tuple<facebook::glean::cpp::schema::Src::File, Repr<facebook::glean::cpp::schema::Src::Range>, String>;
};


namespace schema {

namespace Scip {

struct Location {
  Fact<facebook::glean::cpp::schema::Src::File> file;
  facebook::glean::cpp::schema::Src::Range location;
  std::string name;

  bool operator==(const Location& other) const {
    return std::tie(file,location,name)
             == std::tie(other.file,other.location,other.name);
  }
  bool operator!=(const Location& other) const {
    return std::tie(file,location,name)
             != std::tie(other.file,other.location,other.name);
  }
  bool operator<(const Location& other) const {
    return std::tie(file,location,name)
             < std::tie(other.file,other.location,other.name);
  }
  bool operator<=(const Location& other) const {
    return std::tie(file,location,name)
             <= std::tie(other.file,other.location,other.name);
  }
  bool operator>(const Location& other) const {
    return std::tie(file,location,name)
             > std::tie(other.file,other.location,other.name);
  }
  bool operator>=(const Location& other) const {
    return std::tie(file,location,name)
             >= std::tie(other.file,other.location,other.name);
  }
  void outputRepr(Output<Repr<Location>> out) const {
    outputValue(out, std::make_tuple(file, location, name));
  }
}; // struct Location

struct LocalName : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "scip.LocalName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LocalName

struct IsImplemented : Predicate<std::tuple<Fact<Symbol>, Fact<Symbol>>> {
  static const char* GLEAN_name() {
    return "scip.IsImplemented";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct IsImplemented

struct IsImplementation : Predicate<std::tuple<Fact<Symbol>, Fact<Symbol>>> {
  static const char* GLEAN_name() {
    return "scip.IsImplementation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct IsImplementation

} // namespace Scip

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Scip::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Scip::SomeEntity>, Repr<facebook::glean::cpp::schema::Scip::SomeEntity>, Repr<facebook::glean::cpp::schema::Scip::SomeEntity>, Repr<facebook::glean::cpp::schema::Scip::SomeEntity>, Repr<facebook::glean::cpp::schema::Scip::SomeEntity>, Repr<facebook::glean::cpp::schema::Scip::SomeEntity>>;
};


namespace schema {

namespace Scip {

struct Entity {
  boost::variant<Alt<0, SomeEntity>, Alt<1, SomeEntity>, Alt<2, SomeEntity>, Alt<3, SomeEntity>, Alt<4, SomeEntity>, Alt<5, SomeEntity>> GLEAN_value;

  static Entity rust(const SomeEntity& a) {
    return Entity{Alt<0, SomeEntity>(a)};
  }
  static Entity go(const SomeEntity& a) {
    return Entity{Alt<1, SomeEntity>(a)};
  }
  static Entity typescript(const SomeEntity& a) {
    return Entity{Alt<2, SomeEntity>(a)};
  }
  static Entity java(const SomeEntity& a) {
    return Entity{Alt<3, SomeEntity>(a)};
  }
  static Entity kotlin(const SomeEntity& a) {
    return Entity{Alt<4, SomeEntity>(a)};
  }
  static Entity swift(const SomeEntity& a) {
    return Entity{Alt<5, SomeEntity>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

struct EntityDefinition : Predicate<std::tuple<Entity, Fact<Definition>>> {
  static const char* GLEAN_name() {
    return "scip.EntityDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EntityDefinition

struct EntityLocation : Predicate<std::tuple<Entity, Location>> {
  static const char* GLEAN_name() {
    return "scip.EntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EntityLocation

struct EntityUses : Predicate<std::tuple<Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "scip.EntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EntityUses

struct FileEntityXRefLocation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::Range, Location, Entity>> {
  static const char* GLEAN_name() {
    return "scip.FileEntityXRefLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileEntityXRefLocation

struct ResolveLocation : Predicate<std::tuple<Location, Entity>> {
  static const char* GLEAN_name() {
    return "scip.ResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ResolveLocation

struct SearchBySymbol : Predicate<std::tuple<Fact<Symbol>, Entity>> {
  static const char* GLEAN_name() {
    return "scip.SearchBySymbol";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchBySymbol

struct Documentation : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "scip.Documentation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Documentation

struct DisplayNameSymbol : Predicate<std::tuple<Fact<DisplayName>, Fact<Symbol>>> {
  static const char* GLEAN_name() {
    return "scip.DisplayNameSymbol";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DisplayNameSymbol

struct DisplayName : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "scip.DisplayName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DisplayName

struct DefinitionUses : Predicate<std::tuple<Fact<Definition>, Fact<Reference>>> {
  static const char* GLEAN_name() {
    return "scip.DefinitionUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DefinitionUses

struct DefinitionName : Predicate<std::tuple<Fact<Definition>, Fact<LocalName>>> {
  static const char* GLEAN_name() {
    return "scip.DefinitionName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DefinitionName

struct DefinitionDocumentation : Predicate<std::tuple<Fact<Definition>, Fact<Documentation>>> {
  static const char* GLEAN_name() {
    return "scip.DefinitionDocumentation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DefinitionDocumentation

struct Definition : Predicate<std::tuple<Fact<Symbol>, Fact<FileRange>>> {
  static const char* GLEAN_name() {
    return "scip.Definition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Definition

} // namespace Scip

namespace Python {

namespace Branches {

struct Root : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "python.branches.Root";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Root

struct FileToRoot : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Root>>> {
  static const char* GLEAN_name() {
    return "python.branches.FileToRoot";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileToRoot

struct DirectXRefByFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<facebook::glean::cpp::schema::Python::DeclarationLocation>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "python.branches.DirectXRefByFile";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DirectXRefByFile

} // namespace Branches

struct XRefsViaNameByTarget : Predicate<std::tuple<Fact<Name>, Fact<facebook::glean::cpp::schema::Src::File>, std::vector<facebook::glean::cpp::schema::Src::ByteSpan>>> {
  static const char* GLEAN_name() {
    return "python.XRefsViaNameByTarget";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct XRefsViaNameByTarget

struct XRefsViaName : Predicate<std::tuple<Fact<Name>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "python.XRefsViaName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct XRefsViaName

} // namespace Python

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Python::XRefViaName> {
  using Type = Tuple<facebook::glean::cpp::schema::Python::Name, Repr<facebook::glean::cpp::schema::Src::ByteSpan>>;
};


namespace schema {

namespace Python {

struct XRefViaName {
  Fact<Name> target;
  facebook::glean::cpp::schema::Src::ByteSpan source;

  bool operator==(const XRefViaName& other) const {
    return std::tie(target,source)
             == std::tie(other.target,other.source);
  }
  bool operator!=(const XRefViaName& other) const {
    return std::tie(target,source)
             != std::tie(other.target,other.source);
  }
  bool operator<(const XRefViaName& other) const {
    return std::tie(target,source)
             < std::tie(other.target,other.source);
  }
  bool operator<=(const XRefViaName& other) const {
    return std::tie(target,source)
             <= std::tie(other.target,other.source);
  }
  bool operator>(const XRefViaName& other) const {
    return std::tie(target,source)
             > std::tie(other.target,other.source);
  }
  bool operator>=(const XRefViaName& other) const {
    return std::tie(target,source)
             >= std::tie(other.target,other.source);
  }
  void outputRepr(Output<Repr<XRefViaName>> out) const {
    outputValue(out, std::make_tuple(target, source));
  }
}; // struct XRefViaName

struct XRefsViaNameByFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::vector<XRefViaName>>> {
  static const char* GLEAN_name() {
    return "python.XRefsViaNameByFile";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct XRefsViaNameByFile

struct VariableDeclaration : Predicate<std::tuple<Fact<Name>>> {
  static const char* GLEAN_name() {
    return "python.VariableDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct VariableDeclaration

struct VariableBySName : Predicate<Fact<SName>, Fact<VariableDeclaration>> {
  static const char* GLEAN_name() {
    return "python.VariableBySName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct VariableBySName

} // namespace Python

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Python::TypeInfo> {
  using Type = Tuple<facebook::glean::cpp::schema::Python::Type, Array<Repr<facebook::glean::cpp::schema::Python::XRefViaName>>>;
};


namespace schema {

namespace Python {

struct TypeInfo {
  Fact<Type> displayType;
  std::vector<XRefViaName> xrefs;

  bool operator==(const TypeInfo& other) const {
    return std::tie(displayType,xrefs)
             == std::tie(other.displayType,other.xrefs);
  }
  bool operator!=(const TypeInfo& other) const {
    return std::tie(displayType,xrefs)
             != std::tie(other.displayType,other.xrefs);
  }
  bool operator<(const TypeInfo& other) const {
    return std::tie(displayType,xrefs)
             < std::tie(other.displayType,other.xrefs);
  }
  bool operator<=(const TypeInfo& other) const {
    return std::tie(displayType,xrefs)
             <= std::tie(other.displayType,other.xrefs);
  }
  bool operator>(const TypeInfo& other) const {
    return std::tie(displayType,xrefs)
             > std::tie(other.displayType,other.xrefs);
  }
  bool operator>=(const TypeInfo& other) const {
    return std::tie(displayType,xrefs)
             >= std::tie(other.displayType,other.xrefs);
  }
  void outputRepr(Output<Repr<TypeInfo>> out) const {
    outputValue(out, std::make_tuple(displayType, xrefs));
  }
}; // struct TypeInfo

struct Type : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "python.Type";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Type

struct StringLiteral : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "python.StringLiteral";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct StringLiteral

struct SearchVariableByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<SName>>>, Fact<VariableDeclaration>>> {
  static const char* GLEAN_name() {
    return "python.SearchVariableByName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchVariableByName

struct SearchVariableByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "python.SearchVariableByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchVariableByLowerCaseName

struct SearchModuleByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<SName>>>, Fact<Module>>> {
  static const char* GLEAN_name() {
    return "python.SearchModuleByName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchModuleByName

struct SearchModuleByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "python.SearchModuleByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchModuleByLowerCaseName

struct SearchMethodByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<SName>>>, Fact<FunctionDeclaration>>> {
  static const char* GLEAN_name() {
    return "python.SearchMethodByName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchMethodByName

struct SearchMethodByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "python.SearchMethodByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchMethodByLowerCaseName

struct SearchFunctionByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<SName>>>, Fact<FunctionDeclaration>>> {
  static const char* GLEAN_name() {
    return "python.SearchFunctionByName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchFunctionByName

struct SearchFunctionByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "python.SearchFunctionByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchFunctionByLowerCaseName

struct SearchFieldByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<SName>>>, Fact<VariableDeclaration>>> {
  static const char* GLEAN_name() {
    return "python.SearchFieldByName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchFieldByName

struct SearchFieldByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "python.SearchFieldByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchFieldByLowerCaseName

struct SearchClassByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<SName>>>, Fact<ClassDeclaration>>> {
  static const char* GLEAN_name() {
    return "python.SearchClassByName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchClassByName

struct SearchClassByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "python.SearchClassByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchClassByLowerCaseName

struct SNameToName : Predicate<Fact<SName>, Fact<Name>> {
  static const char* GLEAN_name() {
    return "python.SNameToName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SNameToName

struct SName : Predicate<std::tuple<Fact<Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<SName>>>>> {
  static const char* GLEAN_name() {
    return "python.SName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SName

struct ResolveOriginalName : Predicate<std::tuple<Fact<Name>, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "python.ResolveOriginalName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ResolveOriginalName

} // namespace Python

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Python::Parameter> {
  using Type = Tuple<facebook::glean::cpp::schema::Python::Name, Maybe<Repr<facebook::glean::cpp::schema::Python::TypeInfo>>, Maybe<String>>;
};


namespace schema {

namespace Python {

struct Parameter {
  Fact<Name> name;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, TypeInfo>> typeInfo;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>> value;

  bool operator==(const Parameter& other) const {
    return std::tie(name,typeInfo,value)
             == std::tie(other.name,other.typeInfo,other.value);
  }
  bool operator!=(const Parameter& other) const {
    return std::tie(name,typeInfo,value)
             != std::tie(other.name,other.typeInfo,other.value);
  }
  bool operator<(const Parameter& other) const {
    return std::tie(name,typeInfo,value)
             < std::tie(other.name,other.typeInfo,other.value);
  }
  bool operator<=(const Parameter& other) const {
    return std::tie(name,typeInfo,value)
             <= std::tie(other.name,other.typeInfo,other.value);
  }
  bool operator>(const Parameter& other) const {
    return std::tie(name,typeInfo,value)
             > std::tie(other.name,other.typeInfo,other.value);
  }
  bool operator>=(const Parameter& other) const {
    return std::tie(name,typeInfo,value)
             >= std::tie(other.name,other.typeInfo,other.value);
  }
  void outputRepr(Output<Repr<Parameter>> out) const {
    outputValue(out, std::make_tuple(name, typeInfo, value));
  }
}; // struct Parameter

struct NameToSName : Predicate<Fact<Name>, Fact<SName>> {
  static const char* GLEAN_name() {
    return "python.NameToSName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct NameToSName

struct Name : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "python.Name";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Name

struct ModuleDefinition : Predicate<std::tuple<Fact<Module>>> {
  static const char* GLEAN_name() {
    return "python.ModuleDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ModuleDefinition

struct ModuleBySName : Predicate<Fact<SName>, Fact<Module>> {
  static const char* GLEAN_name() {
    return "python.ModuleBySName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ModuleBySName

struct Module : Predicate<std::tuple<Fact<Name>>> {
  static const char* GLEAN_name() {
    return "python.Module";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Module

struct MethodOverrides : Predicate<std::tuple<Fact<FunctionDeclaration>, Fact<FunctionDeclaration>>> {
  static const char* GLEAN_name() {
    return "python.MethodOverrides";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct MethodOverrides

struct MethodOverriden : Predicate<std::tuple<Fact<FunctionDeclaration>, Fact<FunctionDeclaration>>> {
  static const char* GLEAN_name() {
    return "python.MethodOverriden";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct MethodOverriden

struct MethodByLocalNameStr : Predicate<std::tuple<Fact<ClassDeclaration>, std::string, Fact<FunctionDeclaration>>> {
  static const char* GLEAN_name() {
    return "python.MethodByLocalNameStr";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct MethodByLocalNameStr

struct ImportStatementByAsSName : Predicate<std::tuple<Fact<SName>, Fact<ImportStatement>>> {
  static const char* GLEAN_name() {
    return "python.ImportStatementByAsSName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ImportStatementByAsSName

struct ImportStatementByAsName : Predicate<std::tuple<Fact<Name>, Fact<ImportStatement>>> {
  static const char* GLEAN_name() {
    return "python.ImportStatementByAsName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ImportStatementByAsName

struct ImportStatement : Predicate<std::tuple<Fact<Name>, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "python.ImportStatement";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ImportStatement

struct ImportStarsByFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, Fact<ImportStarStatement>>> {
  static const char* GLEAN_name() {
    return "python.ImportStarsByFile";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ImportStarsByFile

struct ImportStarStatement : Predicate<std::tuple<Fact<Name>, Fact<Module>>> {
  static const char* GLEAN_name() {
    return "python.ImportStarStatement";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ImportStarStatement

struct ImportStarLocation : Predicate<std::tuple<Fact<ImportStarStatement>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "python.ImportStarLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ImportStarLocation

struct FunctionDeclaration : Predicate<std::tuple<Fact<Name>>> {
  static const char* GLEAN_name() {
    return "python.FunctionDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FunctionDeclaration

struct FunctionBySName : Predicate<Fact<SName>, Fact<FunctionDeclaration>> {
  static const char* GLEAN_name() {
    return "python.FunctionBySName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FunctionBySName

struct DerivedClassToBase : Predicate<std::tuple<Fact<ClassDeclaration>, Fact<ClassDeclaration>>> {
  static const char* GLEAN_name() {
    return "python.DerivedClassToBase";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DerivedClassToBase

} // namespace Python

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Python::Definition> {
  using Type = Sum<facebook::glean::cpp::schema::Python::ClassDefinition, facebook::glean::cpp::schema::Python::FunctionDefinition, facebook::glean::cpp::schema::Python::VariableDefinition, facebook::glean::cpp::schema::Python::ModuleDefinition>;
};


namespace schema {

namespace Python {

struct Definition {
  boost::variant<Alt<0, Fact<ClassDefinition>>, Alt<1, Fact<FunctionDefinition>>, Alt<2, Fact<VariableDefinition>>, Alt<3, Fact<ModuleDefinition>>> GLEAN_value;

  static Definition cls(const Fact<ClassDefinition>& a) {
    return Definition{Alt<0, Fact<ClassDefinition>>(a)};
  }
  static Definition func(const Fact<FunctionDefinition>& a) {
    return Definition{Alt<1, Fact<FunctionDefinition>>(a)};
  }
  static Definition variable(const Fact<VariableDefinition>& a) {
    return Definition{Alt<2, Fact<VariableDefinition>>(a)};
  }
  static Definition module(const Fact<ModuleDefinition>& a) {
    return Definition{Alt<3, Fact<ModuleDefinition>>(a)};
  }

  bool operator==(const Definition& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Definition& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Definition& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Definition& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Definition& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Definition& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Definition>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Definition

struct DefinitionLocation : Predicate<std::tuple<Definition, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "python.DefinitionLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DefinitionLocation

struct DefinitionsByFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, Definition>> {
  static const char* GLEAN_name() {
    return "python.DefinitionsByFile";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DefinitionsByFile

struct IsTopLevelDefinition : Predicate<Definition> {
  static const char* GLEAN_name() {
    return "python.IsTopLevelDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct IsTopLevelDefinition

using Decorator = std::string;

} // namespace Python

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Python::DeclarationContainer> {
  using Type = Sum<facebook::glean::cpp::schema::Python::Module, facebook::glean::cpp::schema::Python::ClassDeclaration, facebook::glean::cpp::schema::Python::FunctionDeclaration>;
};


namespace schema {

namespace Python {

struct DeclarationContainer {
  boost::variant<Alt<0, Fact<Module>>, Alt<1, Fact<ClassDeclaration>>, Alt<2, Fact<FunctionDeclaration>>> GLEAN_value;

  static DeclarationContainer module(const Fact<Module>& a) {
    return DeclarationContainer{Alt<0, Fact<Module>>(a)};
  }
  static DeclarationContainer cls(const Fact<ClassDeclaration>& a) {
    return DeclarationContainer{Alt<1, Fact<ClassDeclaration>>(a)};
  }
  static DeclarationContainer func(const Fact<FunctionDeclaration>& a) {
    return DeclarationContainer{Alt<2, Fact<FunctionDeclaration>>(a)};
  }

  bool operator==(const DeclarationContainer& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const DeclarationContainer& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const DeclarationContainer& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const DeclarationContainer& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const DeclarationContainer& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const DeclarationContainer& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<DeclarationContainer>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct DeclarationContainer

struct FunctionDefinition : Predicate<std::tuple<Fact<FunctionDeclaration>, bool, boost::variant<Alt<0, std::tuple<>>, Alt<1, TypeInfo>>, std::vector<Parameter>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::vector<Parameter>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::vector<Parameter>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Parameter>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Parameter>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::vector<Decorator>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, DeclarationContainer>>>> {
  static const char* GLEAN_name() {
    return "python.FunctionDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FunctionDefinition

struct VariableDefinition : Predicate<std::tuple<Fact<VariableDeclaration>, boost::variant<Alt<0, std::tuple<>>, Alt<1, TypeInfo>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, DeclarationContainer>>>> {
  static const char* GLEAN_name() {
    return "python.VariableDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct VariableDefinition

} // namespace Python

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Python::Declaration> {
  using Type = Sum<facebook::glean::cpp::schema::Python::ClassDeclaration, facebook::glean::cpp::schema::Python::FunctionDeclaration, facebook::glean::cpp::schema::Python::VariableDeclaration, facebook::glean::cpp::schema::Python::ImportStatement, facebook::glean::cpp::schema::Python::Module>;
};


namespace schema {

namespace Python {

struct Declaration {
  boost::variant<Alt<0, Fact<ClassDeclaration>>, Alt<1, Fact<FunctionDeclaration>>, Alt<2, Fact<VariableDeclaration>>, Alt<3, Fact<ImportStatement>>, Alt<4, Fact<Module>>> GLEAN_value;

  static Declaration cls(const Fact<ClassDeclaration>& a) {
    return Declaration{Alt<0, Fact<ClassDeclaration>>(a)};
  }
  static Declaration func(const Fact<FunctionDeclaration>& a) {
    return Declaration{Alt<1, Fact<FunctionDeclaration>>(a)};
  }
  static Declaration variable(const Fact<VariableDeclaration>& a) {
    return Declaration{Alt<2, Fact<VariableDeclaration>>(a)};
  }
  static Declaration imp(const Fact<ImportStatement>& a) {
    return Declaration{Alt<3, Fact<ImportStatement>>(a)};
  }
  static Declaration module(const Fact<Module>& a) {
    return Declaration{Alt<4, Fact<Module>>(a)};
  }

  bool operator==(const Declaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Declaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Declaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Declaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Declaration

struct DeclarationDefinition : Predicate<std::tuple<Declaration, Definition>> {
  static const char* GLEAN_name() {
    return "python.DeclarationDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DeclarationDefinition

struct DeclarationDocstring : Predicate<std::tuple<Declaration, facebook::glean::cpp::schema::Src::ByteSpan, std::string>> {
  static const char* GLEAN_name() {
    return "python.DeclarationDocstring";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DeclarationDocstring

struct DeclarationLocation : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "python.DeclarationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DeclarationLocation

struct DeclarationReference : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "python.DeclarationReference";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DeclarationReference

struct DeclarationToName : Predicate<Declaration, Fact<Name>> {
  static const char* GLEAN_name() {
    return "python.DeclarationToName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DeclarationToName

struct DeclarationUses : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "python.DeclarationUses";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DeclarationUses

struct DeclarationWithLocalName : Predicate<std::tuple<Fact<Name>, Declaration>> {
  static const char* GLEAN_name() {
    return "python.DeclarationWithLocalName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DeclarationWithLocalName

struct DeclarationWithName : Predicate<std::tuple<Fact<Name>, Declaration>> {
  static const char* GLEAN_name() {
    return "python.DeclarationWithName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DeclarationWithName

struct DeclarationWithSName : Predicate<std::tuple<Fact<SName>, Declaration>> {
  static const char* GLEAN_name() {
    return "python.DeclarationWithSName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DeclarationWithSName

struct DeclarationsByFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, Declaration>> {
  static const char* GLEAN_name() {
    return "python.DeclarationsByFile";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DeclarationsByFile

struct DefinitionDeclaration : Predicate<std::tuple<Definition, Declaration>> {
  static const char* GLEAN_name() {
    return "python.DefinitionDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DefinitionDeclaration

} // namespace Python

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Python::DirectXRef> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Python::Declaration>, Repr<facebook::glean::cpp::schema::Src::ByteSpan>>;
};


namespace schema {

namespace Python {

struct DirectXRef {
  Declaration target;
  facebook::glean::cpp::schema::Src::ByteSpan source;

  bool operator==(const DirectXRef& other) const {
    return std::tie(target,source)
             == std::tie(other.target,other.source);
  }
  bool operator!=(const DirectXRef& other) const {
    return std::tie(target,source)
             != std::tie(other.target,other.source);
  }
  bool operator<(const DirectXRef& other) const {
    return std::tie(target,source)
             < std::tie(other.target,other.source);
  }
  bool operator<=(const DirectXRef& other) const {
    return std::tie(target,source)
             <= std::tie(other.target,other.source);
  }
  bool operator>(const DirectXRef& other) const {
    return std::tie(target,source)
             > std::tie(other.target,other.source);
  }
  bool operator>=(const DirectXRef& other) const {
    return std::tie(target,source)
             >= std::tie(other.target,other.source);
  }
  void outputRepr(Output<Repr<DirectXRef>> out) const {
    outputValue(out, std::make_tuple(target, source));
  }
}; // struct DirectXRef

struct DirectXRefsByFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, DirectXRef>> {
  static const char* GLEAN_name() {
    return "python.DirectXRefsByFile";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DirectXRefsByFile

struct IsAbstract : Predicate<Declaration> {
  static const char* GLEAN_name() {
    return "python.IsAbstract";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct IsAbstract

struct IsTopLevelDeclaration : Predicate<Declaration> {
  static const char* GLEAN_name() {
    return "python.IsTopLevelDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct IsTopLevelDeclaration

struct NonImportDeclaration : Predicate<Declaration> {
  static const char* GLEAN_name() {
    return "python.NonImportDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct NonImportDeclaration

struct SNameWithDeclaration : Predicate<std::tuple<Declaration, Fact<SName>>> {
  static const char* GLEAN_name() {
    return "python.SNameWithDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SNameWithDeclaration

} // namespace Python

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Yaml::XRefViaName> {
  using Type = Tuple<facebook::glean::cpp::schema::Python::Name, Repr<facebook::glean::cpp::schema::Src::ByteSpan>, Maybe<Repr<facebook::glean::cpp::schema::Python::Declaration>>>;
};


namespace schema {

namespace Yaml {

struct XRefViaName {
  Fact<facebook::glean::cpp::schema::Python::Name> target;
  facebook::glean::cpp::schema::Src::ByteSpan source;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Python::Declaration>> decl;

  bool operator==(const XRefViaName& other) const {
    return std::tie(target,source,decl)
             == std::tie(other.target,other.source,other.decl);
  }
  bool operator!=(const XRefViaName& other) const {
    return std::tie(target,source,decl)
             != std::tie(other.target,other.source,other.decl);
  }
  bool operator<(const XRefViaName& other) const {
    return std::tie(target,source,decl)
             < std::tie(other.target,other.source,other.decl);
  }
  bool operator<=(const XRefViaName& other) const {
    return std::tie(target,source,decl)
             <= std::tie(other.target,other.source,other.decl);
  }
  bool operator>(const XRefViaName& other) const {
    return std::tie(target,source,decl)
             > std::tie(other.target,other.source,other.decl);
  }
  bool operator>=(const XRefViaName& other) const {
    return std::tie(target,source,decl)
             >= std::tie(other.target,other.source,other.decl);
  }
  void outputRepr(Output<Repr<XRefViaName>> out) const {
    outputValue(out, std::make_tuple(target, source, decl));
  }
}; // struct XRefViaName

struct XRefsByFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::vector<XRefViaName>>> {
  static const char* GLEAN_name() {
    return "yaml.XRefsByFile";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct XRefsByFile

} // namespace Yaml

namespace Python {

struct Contains : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "python.Contains";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Contains

struct ContainingTopLevelDeclaration : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "python.ContainingTopLevelDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ContainingTopLevelDeclaration

struct ContainedByTopLevelDeclaration : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "python.ContainedByTopLevelDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ContainedByTopLevelDeclaration

struct ContainedBy : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "python.ContainedBy";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ContainedBy

struct ClassDefinition : Predicate<std::tuple<Fact<ClassDeclaration>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::vector<Fact<ClassDeclaration>>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::vector<Parameter>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::vector<Decorator>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, DeclarationContainer>>>> {
  static const char* GLEAN_name() {
    return "python.ClassDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ClassDefinition

struct ClassDeclaration : Predicate<std::tuple<Fact<Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::vector<Fact<Name>>>>>> {
  static const char* GLEAN_name() {
    return "python.ClassDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ClassDeclaration

struct ClassBySName : Predicate<Fact<SName>, Fact<ClassDeclaration>> {
  static const char* GLEAN_name() {
    return "python.ClassBySName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ClassBySName

struct CalleeToCaller : Predicate<std::tuple<Fact<Name>, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "python.CalleeToCaller";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CalleeToCaller

struct BaseClassToDerived : Predicate<std::tuple<Fact<ClassDeclaration>, Fact<ClassDeclaration>>> {
  static const char* GLEAN_name() {
    return "python.BaseClassToDerived";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct BaseClassToDerived

} // namespace Python

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Python::Argument> {
  using Type = Sum<facebook::glean::cpp::schema::Python::StringLiteral>;
};


namespace schema {

namespace Python {

struct Argument {
  boost::variant<Alt<0, Fact<StringLiteral>>> GLEAN_value;

  static Argument lit(const Fact<StringLiteral>& a) {
    return Argument{Alt<0, Fact<StringLiteral>>(a)};
  }

  bool operator==(const Argument& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Argument& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Argument& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Argument& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Argument& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Argument& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Argument>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Argument

} // namespace Python

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Python::CallArgument> {
  using Type = Tuple<Maybe<facebook::glean::cpp::schema::Python::Name>, Repr<facebook::glean::cpp::schema::Src::ByteSpan>, Maybe<Repr<facebook::glean::cpp::schema::Python::Argument>>>;
};


namespace schema {

namespace Python {

struct CallArgument {
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Name>>> label;
  facebook::glean::cpp::schema::Src::ByteSpan span;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Argument>> argument;

  bool operator==(const CallArgument& other) const {
    return std::tie(label,span,argument)
             == std::tie(other.label,other.span,other.argument);
  }
  bool operator!=(const CallArgument& other) const {
    return std::tie(label,span,argument)
             != std::tie(other.label,other.span,other.argument);
  }
  bool operator<(const CallArgument& other) const {
    return std::tie(label,span,argument)
             < std::tie(other.label,other.span,other.argument);
  }
  bool operator<=(const CallArgument& other) const {
    return std::tie(label,span,argument)
             <= std::tie(other.label,other.span,other.argument);
  }
  bool operator>(const CallArgument& other) const {
    return std::tie(label,span,argument)
             > std::tie(other.label,other.span,other.argument);
  }
  bool operator>=(const CallArgument& other) const {
    return std::tie(label,span,argument)
             >= std::tie(other.label,other.span,other.argument);
  }
  void outputRepr(Output<Repr<CallArgument>> out) const {
    outputValue(out, std::make_tuple(label, span, argument));
  }
}; // struct CallArgument

struct FileCall : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, std::vector<CallArgument>>> {
  static const char* GLEAN_name() {
    return "python.FileCall";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FileCall

} // namespace Python

namespace Pp1 {

struct Use : Predicate<std::tuple<Fact<Macro>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Src::Loc>>, bool, facebook::glean::cpp::schema::Src::Range, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "pp1.Use";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Use

struct Undef : Predicate<std::tuple<Fact<Macro>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "pp1.Undef";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Undef

struct Macro : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "pp1.Macro";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Macro

struct Include : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::Range, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "pp1.Include";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Include

struct DefineUse : Predicate<std::tuple<Fact<Define>, Fact<Use>>> {
  static const char* GLEAN_name() {
    return "pp1.DefineUse";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DefineUse

struct DefineLowerCase : Predicate<std::tuple<std::string, Fact<Define>>> {
  static const char* GLEAN_name() {
    return "pp1.DefineLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DefineLowerCase

struct Define : Predicate<std::tuple<Fact<Macro>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "pp1.Define";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Define

} // namespace Pp1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Lsif::Types::ToolInfo> {
  using Type = Tuple<String, Array<String>, Maybe<String>>;
};


namespace schema {

namespace Lsif {

namespace Types {

struct ToolInfo {
  std::string toolName;
  std::vector<std::string> toolArgs;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>> version;

  bool operator==(const ToolInfo& other) const {
    return std::tie(toolName,toolArgs,version)
             == std::tie(other.toolName,other.toolArgs,other.version);
  }
  bool operator!=(const ToolInfo& other) const {
    return std::tie(toolName,toolArgs,version)
             != std::tie(other.toolName,other.toolArgs,other.version);
  }
  bool operator<(const ToolInfo& other) const {
    return std::tie(toolName,toolArgs,version)
             < std::tie(other.toolName,other.toolArgs,other.version);
  }
  bool operator<=(const ToolInfo& other) const {
    return std::tie(toolName,toolArgs,version)
             <= std::tie(other.toolName,other.toolArgs,other.version);
  }
  bool operator>(const ToolInfo& other) const {
    return std::tie(toolName,toolArgs,version)
             > std::tie(other.toolName,other.toolArgs,other.version);
  }
  bool operator>=(const ToolInfo& other) const {
    return std::tie(toolName,toolArgs,version)
             >= std::tie(other.toolName,other.toolArgs,other.version);
  }
  void outputRepr(Output<Repr<ToolInfo>> out) const {
    outputValue(out, std::make_tuple(toolName, toolArgs, version));
  }
}; // struct ToolInfo

} // namespace Types

} // namespace Lsif

namespace Scip {

struct Metadata : Predicate<std::tuple<ProtocolVersion, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Lsif::Types::ToolInfo>>, std::string, TextEncoding>> {
  static const char* GLEAN_name() {
    return "scip.Metadata";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Metadata

} // namespace Scip

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Lsif::Types::SymbolKind> {
  using Type = Enum<27>;
};


namespace schema {

namespace Lsif {

namespace Types {

enum class SymbolKind { File, Module, Namespace, Package, Class_, Method, Property, Field, Constructor, Enum_, Interface, Function, Variable, Constant, String, Number, Boolean, Array_, Object_, Key, Null, EnumMember, Struct, Event, Operator, TypeParameter, Unknown };

} // namespace Types

} // namespace Lsif

namespace Scip {

struct EntityKind : Predicate<std::tuple<Entity, facebook::glean::cpp::schema::Lsif::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "scip.EntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EntityKind

struct SearchByNameKind : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Lsif::Types::SymbolKind>>, Entity>> {
  static const char* GLEAN_name() {
    return "scip.SearchByNameKind";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchByNameKind

struct SymbolKind : Predicate<std::tuple<Fact<Symbol>, facebook::glean::cpp::schema::Lsif::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "scip.SymbolKind";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SymbolKind

} // namespace Scip

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Lsif::Types::RangeSpan> {
  using Type = Tuple<Nat, Nat, Nat, Nat>;
};


namespace schema {

namespace Lsif {

namespace Types {

struct RangeSpan {
  uint64_t lineBegin;
  uint64_t columnBegin;
  uint64_t lineEnd;
  uint64_t columnEnd;

  bool operator==(const RangeSpan& other) const {
    return std::tie(lineBegin,columnBegin,lineEnd,columnEnd)
             == std::tie(other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  bool operator!=(const RangeSpan& other) const {
    return std::tie(lineBegin,columnBegin,lineEnd,columnEnd)
             != std::tie(other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  bool operator<(const RangeSpan& other) const {
    return std::tie(lineBegin,columnBegin,lineEnd,columnEnd)
             < std::tie(other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  bool operator<=(const RangeSpan& other) const {
    return std::tie(lineBegin,columnBegin,lineEnd,columnEnd)
             <= std::tie(other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  bool operator>(const RangeSpan& other) const {
    return std::tie(lineBegin,columnBegin,lineEnd,columnEnd)
             > std::tie(other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  bool operator>=(const RangeSpan& other) const {
    return std::tie(lineBegin,columnBegin,lineEnd,columnEnd)
             >= std::tie(other.lineBegin,other.columnBegin,other.lineEnd,other.columnEnd);
  }
  void outputRepr(Output<Repr<RangeSpan>> out) const {
    outputValue(out, std::make_tuple(lineBegin, columnBegin, lineEnd, columnEnd));
  }
}; // struct RangeSpan

struct ToSrcRange : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, RangeSpan, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "lsif.types.ToSrcRange";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ToSrcRange

} // namespace Types

} // namespace Lsif

namespace Scip {

struct DefinitionLocation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Lsif::Types::RangeSpan, Fact<Definition>>> {
  static const char* GLEAN_name() {
    return "scip.DefinitionLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DefinitionLocation

struct FileRange : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Lsif::Types::RangeSpan>> {
  static const char* GLEAN_name() {
    return "scip.FileRange";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileRange

struct FileXLangSymbolRef : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Lsif::Types::RangeSpan, Fact<Symbol>>> {
  static const char* GLEAN_name() {
    return "scip.FileXLangSymbolRef";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileXLangSymbolRef

struct ReferenceLocation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Lsif::Types::RangeSpan, Fact<Reference>>> {
  static const char* GLEAN_name() {
    return "scip.ReferenceLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ReferenceLocation

} // namespace Scip

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Lsif::Types::LanguageId> {
  using Type = Enum<59>;
};


namespace schema {

namespace Lsif {

namespace Types {

enum class LanguageId { ABAP, WindowsBat, BibTeX, Clojure, Coffeescript, C, Cpp, CSharp, CSS, Diff, Dart, Dockerfile, Elixir, Erlang, FSharp, Git, Go, Groovy, Handlebars, Haskell, HTML, Ini, Java, JavaScript, JavaScriptReact, JSON, LaTeX, Less, Lua, Makefile, Markdown, ObjectiveC, ObjectiveCpp, Perl, Perl6, PHP, Powershell, Pug, Python, R, Razor, Ruby, Rust, SCSS, Scala, ShaderLab, Shell, SQL, Swift, TypeScript, TypeScriptReact, TeX, VisualBasic, XML, XSL, YAML, UnknownLanguage, Kotlin, OCaml };

} // namespace Types

} // namespace Lsif

namespace Scip {

struct FileLanguage : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Lsif::Types::LanguageId>> {
  static const char* GLEAN_name() {
    return "scip.FileLanguage";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileLanguage

struct TagDefinition : Predicate<std::tuple<facebook::glean::cpp::schema::Lsif::Types::LanguageId, Fact<Definition>, Entity>> {
  static const char* GLEAN_name() {
    return "scip.TagDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TagDefinition

} // namespace Scip

namespace Lsif {

namespace Types {

struct FromSrcRange : Predicate<std::tuple<facebook::glean::cpp::schema::Src::Range, Fact<facebook::glean::cpp::schema::Src::File>, RangeSpan>> {
  static const char* GLEAN_name() {
    return "lsif.types.FromSrcRange";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FromSrcRange

} // namespace Types

} // namespace Lsif

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Lsif::SomeEntity> {
  using Type = Sum<facebook::glean::cpp::schema::Lsif::Declaration, facebook::glean::cpp::schema::Lsif::DefinitionMoniker>;
};


namespace schema {

namespace Lsif {

struct SomeEntity {
  boost::variant<Alt<0, Fact<Declaration>>, Alt<1, Fact<DefinitionMoniker>>> GLEAN_value;

  static SomeEntity decl(const Fact<Declaration>& a) {
    return SomeEntity{Alt<0, Fact<Declaration>>(a)};
  }
  static SomeEntity defn(const Fact<DefinitionMoniker>& a) {
    return SomeEntity{Alt<1, Fact<DefinitionMoniker>>(a)};
  }

  bool operator==(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<SomeEntity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct SomeEntity

struct Reference : Predicate<std::tuple<Fact<Document>, Fact<Range>, Fact<Definition>>> {
  static const char* GLEAN_name() {
    return "lsif.Reference";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct Reference

struct Range : Predicate<std::tuple<facebook::glean::cpp::schema::Lsif::Types::RangeSpan, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Lsif::Types::RangeSpan>>, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "lsif.Range";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct Range

struct ProjectDocument : Predicate<std::tuple<Fact<Document>, Fact<Project>>> {
  static const char* GLEAN_name() {
    return "lsif.ProjectDocument";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ProjectDocument

struct Project : Predicate<std::tuple<facebook::glean::cpp::schema::Lsif::Types::LanguageId>> {
  static const char* GLEAN_name() {
    return "lsif.Project";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct Project

struct PackageInformation : Predicate<std::tuple<std::string, std::string, std::string>> {
  static const char* GLEAN_name() {
    return "lsif.PackageInformation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PackageInformation

struct NameLowerCase : Predicate<std::tuple<std::string, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "lsif.NameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct NameLowerCase

struct NameDefinition : Predicate<std::tuple<Fact<Name>, Fact<DefinitionMoniker>>> {
  static const char* GLEAN_name() {
    return "lsif.NameDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct NameDefinition

struct Name : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "lsif.Name";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct Name

struct MonikerSymbolKind : Predicate<std::tuple<Fact<Moniker>, facebook::glean::cpp::schema::Lsif::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "lsif.MonikerSymbolKind";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct MonikerSymbolKind

struct MonikerScheme : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "lsif.MonikerScheme";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct MonikerScheme

} // namespace Lsif

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Lsif::MonikerKind> {
  using Type = Enum<4>;
};


namespace schema {

namespace Lsif {

enum class MonikerKind { Export, Local, Import, Implementation };

struct MonikerId : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "lsif.MonikerId";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct MonikerId

struct MonikerDefinition : Predicate<std::tuple<Fact<MonikerId>, Fact<Moniker>, Fact<Definition>>> {
  static const char* GLEAN_name() {
    return "lsif.MonikerDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct MonikerDefinition

struct Moniker : Predicate<std::tuple<MonikerKind, Fact<MonikerScheme>, Fact<MonikerId>>> {
  static const char* GLEAN_name() {
    return "lsif.Moniker";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct Moniker

struct Metadata : Predicate<std::tuple<std::string, std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Lsif::Types::ToolInfo>>>> {
  static const char* GLEAN_name() {
    return "lsif.Metadata";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct Metadata

} // namespace Lsif

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Lsif::Location> {
  using Type = Tuple<String, facebook::glean::cpp::schema::Src::File, Repr<facebook::glean::cpp::schema::Src::Range>>;
};


namespace schema {

namespace Lsif {

struct Location {
  std::string name;
  Fact<facebook::glean::cpp::schema::Src::File> file;
  facebook::glean::cpp::schema::Src::Range location;

  bool operator==(const Location& other) const {
    return std::tie(name,file,location)
             == std::tie(other.name,other.file,other.location);
  }
  bool operator!=(const Location& other) const {
    return std::tie(name,file,location)
             != std::tie(other.name,other.file,other.location);
  }
  bool operator<(const Location& other) const {
    return std::tie(name,file,location)
             < std::tie(other.name,other.file,other.location);
  }
  bool operator<=(const Location& other) const {
    return std::tie(name,file,location)
             <= std::tie(other.name,other.file,other.location);
  }
  bool operator>(const Location& other) const {
    return std::tie(name,file,location)
             > std::tie(other.name,other.file,other.location);
  }
  bool operator>=(const Location& other) const {
    return std::tie(name,file,location)
             >= std::tie(other.name,other.file,other.location);
  }
  void outputRepr(Output<Repr<Location>> out) const {
    outputValue(out, std::make_tuple(name, file, location));
  }
}; // struct Location

struct HoverText : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "lsif.HoverText";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HoverText

struct HoverContent : Predicate<std::tuple<Fact<HoverText>, facebook::glean::cpp::schema::Lsif::Types::LanguageId>> {
  static const char* GLEAN_name() {
    return "lsif.HoverContent";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HoverContent

} // namespace Lsif

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Lsif::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>>;
};


namespace schema {

namespace Lsif {

struct Entity {
  boost::variant<Alt<0, SomeEntity>, Alt<1, SomeEntity>, Alt<2, SomeEntity>, Alt<3, SomeEntity>, Alt<4, SomeEntity>, Alt<5, SomeEntity>, Alt<6, SomeEntity>, Alt<7, SomeEntity>, Alt<8, SomeEntity>, Alt<9, SomeEntity>, Alt<10, SomeEntity>, Alt<11, SomeEntity>> GLEAN_value;

  static Entity erlang(const SomeEntity& a) {
    return Entity{Alt<0, SomeEntity>(a)};
  }
  static Entity fsharp(const SomeEntity& a) {
    return Entity{Alt<1, SomeEntity>(a)};
  }
  static Entity go(const SomeEntity& a) {
    return Entity{Alt<2, SomeEntity>(a)};
  }
  static Entity haskell(const SomeEntity& a) {
    return Entity{Alt<3, SomeEntity>(a)};
  }
  static Entity java(const SomeEntity& a) {
    return Entity{Alt<4, SomeEntity>(a)};
  }
  static Entity kotlin(const SomeEntity& a) {
    return Entity{Alt<5, SomeEntity>(a)};
  }
  static Entity ocaml(const SomeEntity& a) {
    return Entity{Alt<6, SomeEntity>(a)};
  }
  static Entity python(const SomeEntity& a) {
    return Entity{Alt<7, SomeEntity>(a)};
  }
  static Entity rust(const SomeEntity& a) {
    return Entity{Alt<8, SomeEntity>(a)};
  }
  static Entity scala(const SomeEntity& a) {
    return Entity{Alt<9, SomeEntity>(a)};
  }
  static Entity swift(const SomeEntity& a) {
    return Entity{Alt<10, SomeEntity>(a)};
  }
  static Entity typescript(const SomeEntity& a) {
    return Entity{Alt<11, SomeEntity>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

struct EntityDefinition : Predicate<std::tuple<Entity, Fact<DefinitionMoniker>>> {
  static const char* GLEAN_name() {
    return "lsif.EntityDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct EntityDefinition

struct EntityKind : Predicate<std::tuple<Entity, facebook::glean::cpp::schema::Lsif::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "lsif.EntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct EntityKind

struct EntityLocation : Predicate<std::tuple<Entity, Location>> {
  static const char* GLEAN_name() {
    return "lsif.EntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct EntityLocation

struct EntityUses : Predicate<std::tuple<Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "lsif.EntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct EntityUses

struct FileEntityXRefLocation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::Range, Location, Entity>> {
  static const char* GLEAN_name() {
    return "lsif.FileEntityXRefLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FileEntityXRefLocation

struct ResolveLocation : Predicate<std::tuple<Location, Entity>> {
  static const char* GLEAN_name() {
    return "lsif.ResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ResolveLocation

struct SearchByExactLocation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Lsif::Types::RangeSpan, Entity>> {
  static const char* GLEAN_name() {
    return "lsif.SearchByExactLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct SearchByExactLocation

struct SearchByExactLocationAndName : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Name>, facebook::glean::cpp::schema::Lsif::Types::RangeSpan, Entity>> {
  static const char* GLEAN_name() {
    return "lsif.SearchByExactLocationAndName";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct SearchByExactLocationAndName

struct SearchByMoniker : Predicate<std::tuple<Fact<MonikerId>, Entity>> {
  static const char* GLEAN_name() {
    return "lsif.SearchByMoniker";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct SearchByMoniker

struct SearchByName : Predicate<std::tuple<Fact<Name>, Entity>> {
  static const char* GLEAN_name() {
    return "lsif.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct SearchByName

struct SearchNonLocalByLocation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Name>, Entity>> {
  static const char* GLEAN_name() {
    return "lsif.SearchNonLocalByLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct SearchNonLocalByLocation

struct TagDefinition : Predicate<std::tuple<facebook::glean::cpp::schema::Lsif::Types::LanguageId, Fact<DefinitionMoniker>, Entity>> {
  static const char* GLEAN_name() {
    return "lsif.TagDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct TagDefinition

struct Document : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Lsif::Types::LanguageId>> {
  static const char* GLEAN_name() {
    return "lsif.Document";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct Document

struct DefinitionUse : Predicate<std::tuple<Fact<Definition>, Fact<Document>, Fact<Range>>> {
  static const char* GLEAN_name() {
    return "lsif.DefinitionUse";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct DefinitionUse

struct DefinitionMoniker : Predicate<std::tuple<Fact<Definition>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Moniker>>>>> {
  static const char* GLEAN_name() {
    return "lsif.DefinitionMoniker";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct DefinitionMoniker

struct DefinitionLocation : Predicate<std::tuple<Fact<Definition>, Location>> {
  static const char* GLEAN_name() {
    return "lsif.DefinitionLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct DefinitionLocation

struct DefinitionKind : Predicate<std::tuple<Fact<Definition>, facebook::glean::cpp::schema::Lsif::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "lsif.DefinitionKind";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct DefinitionKind

struct DefinitionHover : Predicate<std::tuple<Fact<Definition>, Fact<HoverContent>>> {
  static const char* GLEAN_name() {
    return "lsif.DefinitionHover";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct DefinitionHover

struct Definition : Predicate<std::tuple<Fact<Document>, Fact<Range>>> {
  static const char* GLEAN_name() {
    return "lsif.Definition";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct Definition

struct Declaration : Predicate<std::tuple<Fact<Document>, Fact<Range>>> {
  static const char* GLEAN_name() {
    return "lsif.Declaration";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct Declaration

} // namespace Lsif

namespace Kotlin {

namespace Alpha {

struct VariableParent : Predicate<std::tuple<Fact<VariableDeclaration>, Fact<MethodDeclaration>>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.VariableParent";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct VariableParent

struct VariableDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, Fact<Type>, Fact<DeclarationLocation>>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.VariableDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct VariableDeclaration

struct TypeArg : Predicate<std::tuple<Fact<Type>>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.TypeArg";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct TypeArg

struct Type : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Type>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<DeclarationLocation>>>, std::vector<Fact<TypeArg>>, bool>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.Type";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct Type

struct DeclarationLocation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.DeclarationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct DeclarationLocation

} // namespace Alpha

} // namespace Kotlin

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Kotlin::Alpha::Declaration> {
  using Type = Sum<facebook::glean::cpp::schema::Kotlin::Alpha::ClassDeclaration, facebook::glean::cpp::schema::Kotlin::Alpha::MethodDeclaration, facebook::glean::cpp::schema::Kotlin::Alpha::VariableDeclaration>;
};


namespace schema {

namespace Kotlin {

namespace Alpha {

struct Declaration {
  boost::variant<Alt<0, Fact<ClassDeclaration>>, Alt<1, Fact<MethodDeclaration>>, Alt<2, Fact<VariableDeclaration>>> GLEAN_value;

  static Declaration class_(const Fact<ClassDeclaration>& a) {
    return Declaration{Alt<0, Fact<ClassDeclaration>>(a)};
  }
  static Declaration method(const Fact<MethodDeclaration>& a) {
    return Declaration{Alt<1, Fact<MethodDeclaration>>(a)};
  }
  static Declaration variable(const Fact<VariableDeclaration>& a) {
    return Declaration{Alt<2, Fact<VariableDeclaration>>(a)};
  }

  bool operator==(const Declaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Declaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Declaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Declaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Declaration

struct DeclarationFileLocation : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, std::string>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.DeclarationFileLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct DeclarationFileLocation

struct ExtendsDeclaration : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.ExtendsDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ExtendsDeclaration

struct FileDeclarations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Declaration>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.FileDeclarations";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FileDeclarations

struct MethodDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>, std::vector<Fact<VariableDeclaration>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>>, facebook::glean::cpp::schema::Src::Loc, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<DeclarationLocation>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Declaration>>>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.MethodDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct MethodDeclaration

struct ParentDeclaration : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.ParentDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ParentDeclaration

} // namespace Alpha

} // namespace Kotlin

namespace Search {

namespace Kotlin {

struct SearchByQName : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, facebook::glean::cpp::schema::Kotlin::Alpha::Declaration>> {
  static const char* GLEAN_name() {
    return "search.kotlin.SearchByQName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchByQName

} // namespace Kotlin

} // namespace Search

namespace Symbolid {

namespace Kotlin {

struct LookupDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, facebook::glean::cpp::schema::Kotlin::Alpha::Declaration>> {
  static const char* GLEAN_name() {
    return "symbolid.kotlin.LookupDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupDeclaration

struct LookupMethodDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>, facebook::glean::cpp::schema::Kotlin::Alpha::Declaration>> {
  static const char* GLEAN_name() {
    return "symbolid.kotlin.LookupMethodDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupMethodDeclaration

} // namespace Kotlin

} // namespace Symbolid

namespace Kotlin {

namespace Alpha {

struct ContainsDeclaration : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.ContainsDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ContainsDeclaration

struct ClassMember : Predicate<std::tuple<Fact<ClassDeclaration>, Fact<MethodDeclaration>>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.ClassMember";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ClassMember

struct ClassDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, std::vector<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>>, Fact<DeclarationLocation>>> {
  static const char* GLEAN_name() {
    return "kotlin.alpha.ClassDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ClassDeclaration

} // namespace Alpha

} // namespace Kotlin

namespace Javakotlin {

namespace Alpha {

struct Type : Predicate<boost::variant<Alt<0, std::string>, Alt<1, Fact<Path>>, Alt<2, Fact<Type>>>> {
  static const char* GLEAN_name() {
    return "javakotlin.alpha.Type";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Type

struct QName : Predicate<std::tuple<Fact<Name>, Fact<Path>>> {
  static const char* GLEAN_name() {
    return "javakotlin.alpha.QName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct QName

struct Path : Predicate<std::tuple<Fact<Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Path>>>>> {
  static const char* GLEAN_name() {
    return "javakotlin.alpha.Path";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Path

struct NameLowerCase : Predicate<std::tuple<std::string, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "javakotlin.alpha.NameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct NameLowerCase

struct Name : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "javakotlin.alpha.Name";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Name

struct MethodName : Predicate<std::tuple<Fact<QName>, std::vector<Fact<Type>>>> {
  static const char* GLEAN_name() {
    return "javakotlin.alpha.MethodName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct MethodName

} // namespace Alpha

} // namespace Javakotlin

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Java::Alpha::XRefTarget> {
  using Type = Sum<facebook::glean::cpp::schema::Javakotlin::Alpha::QName, facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName, facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName, facebook::glean::cpp::schema::Javakotlin::Alpha::QName>;
};


namespace schema {

namespace Java {

namespace Alpha {

struct XRefTarget {
  boost::variant<Alt<0, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>>, Alt<1, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>>, Alt<2, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>>, Alt<3, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>>> GLEAN_value;

  static XRefTarget definition_(const Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>& a) {
    return XRefTarget{Alt<0, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>>(a)};
  }
  static XRefTarget ctor_(const Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>& a) {
    return XRefTarget{Alt<1, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>>(a)};
  }
  static XRefTarget method_(const Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>& a) {
    return XRefTarget{Alt<2, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>>(a)};
  }
  static XRefTarget field_(const Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>& a) {
    return XRefTarget{Alt<3, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>>(a)};
  }

  bool operator==(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<XRefTarget>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct XRefTarget

struct XRefFile : Predicate<std::tuple<Fact<XRef>, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "java.alpha.XRefFile";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct XRefFile

struct XRef : Predicate<std::tuple<XRefTarget, std::vector<facebook::glean::cpp::schema::Src::ByteSpan>>> {
  static const char* GLEAN_name() {
    return "java.alpha.XRef";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct XRef

} // namespace Alpha

} // namespace Java

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Java::Alpha::Wildcard> {
  using Type = Sum<facebook::glean::cpp::schema::Java::Alpha::Type, facebook::glean::cpp::schema::Java::Alpha::Type, Bool>;
};


namespace schema {

namespace Java {

namespace Alpha {

struct Wildcard {
  boost::variant<Alt<0, Fact<Type>>, Alt<1, Fact<Type>>, Alt<2, bool>> GLEAN_value;

  static Wildcard extends_(const Fact<Type>& a) {
    return Wildcard{Alt<0, Fact<Type>>(a)};
  }
  static Wildcard super_(const Fact<Type>& a) {
    return Wildcard{Alt<1, Fact<Type>>(a)};
  }
  static Wildcard unbounded(const bool& a) {
    return Wildcard{Alt<2, bool>(a)};
  }

  bool operator==(const Wildcard& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Wildcard& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Wildcard& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Wildcard& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Wildcard& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Wildcard& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Wildcard>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Wildcard

struct TypeVar : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Name>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.TypeVar";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TypeVar

struct TypeParam : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Name>, std::vector<Fact<Type>>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.TypeParam";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TypeParam

struct TypeOfTypeArgs : Predicate<std::tuple<Fact<Type>, Fact<Type>>> {
  static const char* GLEAN_name() {
    return "java.alpha.TypeOfTypeArgs";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TypeOfTypeArgs

struct TypeArg : Predicate<boost::variant<Alt<0, Fact<Type>>, Alt<1, Wildcard>>> {
  static const char* GLEAN_name() {
    return "java.alpha.TypeArg";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TypeArg

struct PrimitiveType : Predicate<std::tuple<std::string>> {
  static const char* GLEAN_name() {
    return "java.alpha.PrimitiveType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct PrimitiveType

struct PackageDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Name>, std::vector<Fact<Annotation>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Path>>>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.PackageDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct PackageDeclaration

struct ObjectType : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.ObjectType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ObjectType

} // namespace Alpha

} // namespace Java

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Java::Alpha::Modifier> {
  using Type = Enum<12>;
};


namespace schema {

namespace Java {

namespace Alpha {

enum class Modifier { abstract_, default_, final_, native_, private_, protected_, public_, static_, strictfp_, synchronized_, transient_, volatile_ };

struct ParameterDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, Fact<Type>, std::vector<Fact<Annotation>>, std::vector<Modifier>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.ParameterDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ParameterDeclaration

struct InterfaceInheritance : Predicate<std::tuple<Fact<Type>, Fact<ClassDeclaration>>> {
  static const char* GLEAN_name() {
    return "java.alpha.InterfaceInheritance";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct InterfaceInheritance

struct Inheritance : Predicate<std::tuple<Fact<Type>, Fact<ClassDeclaration>>> {
  static const char* GLEAN_name() {
    return "java.alpha.Inheritance";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Inheritance

struct ImportDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Name>, bool, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Path>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.ImportDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ImportDeclaration

struct FileXRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::vector<Fact<XRef>>>> {
  static const char* GLEAN_name() {
    return "java.alpha.FileXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileXRefs

} // namespace Alpha

} // namespace Java

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Java::Alpha::ExecutableDefinition> {
  using Type = Sum<facebook::glean::cpp::schema::Java::Alpha::ConstructorDeclaration, facebook::glean::cpp::schema::Java::Alpha::MethodDeclaration>;
};


namespace schema {

namespace Java {

namespace Alpha {

struct ExecutableDefinition {
  boost::variant<Alt<0, Fact<ConstructorDeclaration>>, Alt<1, Fact<MethodDeclaration>>> GLEAN_value;

  static ExecutableDefinition constructor(const Fact<ConstructorDeclaration>& a) {
    return ExecutableDefinition{Alt<0, Fact<ConstructorDeclaration>>(a)};
  }
  static ExecutableDefinition method(const Fact<MethodDeclaration>& a) {
    return ExecutableDefinition{Alt<1, Fact<MethodDeclaration>>(a)};
  }

  bool operator==(const ExecutableDefinition& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const ExecutableDefinition& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const ExecutableDefinition& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const ExecutableDefinition& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const ExecutableDefinition& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const ExecutableDefinition& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<ExecutableDefinition>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct ExecutableDefinition

struct ExecutableDefnLocation : Predicate<std::tuple<ExecutableDefinition, std::string, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.ExecutableDefnLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ExecutableDefnLocation

struct LocalDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, Fact<Type>, std::vector<Fact<Annotation>>, std::vector<Modifier>, ExecutableDefinition, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.LocalDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LocalDeclaration

} // namespace Alpha

} // namespace Java

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Java::Alpha::Definition> {
  using Type = Sum<facebook::glean::cpp::schema::Java::Alpha::ClassDeclaration, facebook::glean::cpp::schema::Java::Alpha::InterfaceDeclaration, facebook::glean::cpp::schema::Java::Alpha::EnumDeclaration>;
};


namespace schema {

namespace Java {

namespace Alpha {

struct Definition {
  boost::variant<Alt<0, Fact<ClassDeclaration>>, Alt<1, Fact<InterfaceDeclaration>>, Alt<2, Fact<EnumDeclaration>>> GLEAN_value;

  static Definition class_(const Fact<ClassDeclaration>& a) {
    return Definition{Alt<0, Fact<ClassDeclaration>>(a)};
  }
  static Definition interface_(const Fact<InterfaceDeclaration>& a) {
    return Definition{Alt<1, Fact<InterfaceDeclaration>>(a)};
  }
  static Definition enum_(const Fact<EnumDeclaration>& a) {
    return Definition{Alt<2, Fact<EnumDeclaration>>(a)};
  }

  bool operator==(const Definition& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Definition& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Definition& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Definition& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Definition& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Definition& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Definition>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Definition

struct DefinitionLocation : Predicate<std::tuple<Definition, std::string, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.DefinitionLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DefinitionLocation

struct EnumDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, std::vector<Fact<Annotation>>, std::vector<Modifier>, std::vector<Fact<Type>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Definition>>, facebook::glean::cpp::schema::Src::ByteSpan, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "java.alpha.EnumDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EnumDeclaration

struct FieldDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, Fact<Type>, std::vector<Fact<Annotation>>, std::vector<Modifier>, Definition, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.FieldDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FieldDeclaration

struct InterfaceDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, std::vector<Fact<Annotation>>, std::vector<Modifier>, std::vector<Fact<Type>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Definition>>, std::vector<Fact<TypeParam>>, facebook::glean::cpp::schema::Src::ByteSpan, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "java.alpha.InterfaceDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct InterfaceDeclaration

struct MethodDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>, std::vector<Fact<ParameterDeclaration>>, Fact<Type>, std::vector<Fact<Annotation>>, std::vector<Modifier>, std::vector<Fact<TypeParam>>, std::vector<Fact<Type>>, Definition, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.MethodDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct MethodDeclaration

} // namespace Alpha

} // namespace Java

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Java::Alpha::Declaration> {
  using Type = Sum<facebook::glean::cpp::schema::Java::Alpha::ParameterDeclaration, facebook::glean::cpp::schema::Java::Alpha::LocalDeclaration, facebook::glean::cpp::schema::Java::Alpha::FieldDeclaration, facebook::glean::cpp::schema::Java::Alpha::ConstructorDeclaration, facebook::glean::cpp::schema::Java::Alpha::MethodDeclaration, facebook::glean::cpp::schema::Java::Alpha::InterfaceDeclaration, facebook::glean::cpp::schema::Java::Alpha::ClassDeclaration, facebook::glean::cpp::schema::Java::Alpha::EnumDeclaration>;
};


namespace schema {

namespace Java {

namespace Alpha {

struct Declaration {
  boost::variant<Alt<0, Fact<ParameterDeclaration>>, Alt<1, Fact<LocalDeclaration>>, Alt<2, Fact<FieldDeclaration>>, Alt<3, Fact<ConstructorDeclaration>>, Alt<4, Fact<MethodDeclaration>>, Alt<5, Fact<InterfaceDeclaration>>, Alt<6, Fact<ClassDeclaration>>, Alt<7, Fact<EnumDeclaration>>> GLEAN_value;

  static Declaration param(const Fact<ParameterDeclaration>& a) {
    return Declaration{Alt<0, Fact<ParameterDeclaration>>(a)};
  }
  static Declaration local(const Fact<LocalDeclaration>& a) {
    return Declaration{Alt<1, Fact<LocalDeclaration>>(a)};
  }
  static Declaration field(const Fact<FieldDeclaration>& a) {
    return Declaration{Alt<2, Fact<FieldDeclaration>>(a)};
  }
  static Declaration ctor(const Fact<ConstructorDeclaration>& a) {
    return Declaration{Alt<3, Fact<ConstructorDeclaration>>(a)};
  }
  static Declaration method(const Fact<MethodDeclaration>& a) {
    return Declaration{Alt<4, Fact<MethodDeclaration>>(a)};
  }
  static Declaration interface_(const Fact<InterfaceDeclaration>& a) {
    return Declaration{Alt<5, Fact<InterfaceDeclaration>>(a)};
  }
  static Declaration class_(const Fact<ClassDeclaration>& a) {
    return Declaration{Alt<6, Fact<ClassDeclaration>>(a)};
  }
  static Declaration enum_(const Fact<EnumDeclaration>& a) {
    return Declaration{Alt<7, Fact<EnumDeclaration>>(a)};
  }

  bool operator==(const Declaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Declaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Declaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Declaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Declaration

struct DeclarationAnnotations : Predicate<std::tuple<Declaration, std::vector<Fact<Annotation>>>> {
  static const char* GLEAN_name() {
    return "java.alpha.DeclarationAnnotations";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationAnnotations

struct DeclarationComment : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.DeclarationComment";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationComment

struct DeclarationLocation : Predicate<std::tuple<Declaration, std::string, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.DeclarationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationLocation

struct DeclarationType : Predicate<std::tuple<Declaration, Fact<Type>>> {
  static const char* GLEAN_name() {
    return "java.alpha.DeclarationType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationType

struct DeclarationUses : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, std::vector<facebook::glean::cpp::schema::Src::ByteSpan>>> {
  static const char* GLEAN_name() {
    return "java.alpha.DeclarationUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationUses

struct DeclarationXRefTarget : Predicate<std::tuple<Declaration, XRefTarget>> {
  static const char* GLEAN_name() {
    return "java.alpha.DeclarationXRefTarget";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationXRefTarget

struct ExtendedByDeclaration : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "java.alpha.ExtendedByDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ExtendedByDeclaration

struct ExtendsDeclaration : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "java.alpha.ExtendsDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ExtendsDeclaration

struct FileDeclarations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Declaration>> {
  static const char* GLEAN_name() {
    return "java.alpha.FileDeclarations";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileDeclarations

struct ParentDeclaration : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "java.alpha.ParentDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ParentDeclaration

struct QNameToDefinition : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, Declaration>> {
  static const char* GLEAN_name() {
    return "java.alpha.QNameToDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct QNameToDefinition

struct XRefOfType : Predicate<std::tuple<Fact<Type>, Declaration, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.XRefOfType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct XRefOfType

struct XRefTargetDeclaration : Predicate<std::tuple<XRefTarget, Declaration>> {
  static const char* GLEAN_name() {
    return "java.alpha.XRefTargetDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct XRefTargetDeclaration

} // namespace Alpha

} // namespace Java

namespace Search {

namespace Java {

struct SearchByQName : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, facebook::glean::cpp::schema::Java::Alpha::Declaration>> {
  static const char* GLEAN_name() {
    return "search.java.SearchByQName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchByQName

} // namespace Java

} // namespace Search

namespace Symbolid {

namespace Java {

struct LookupDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, facebook::glean::cpp::schema::Java::Alpha::Declaration>> {
  static const char* GLEAN_name() {
    return "symbolid.java.LookupDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupDeclaration

struct LookupMethodDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>, facebook::glean::cpp::schema::Java::Alpha::Declaration>> {
  static const char* GLEAN_name() {
    return "symbolid.java.LookupMethodDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupMethodDeclaration

} // namespace Java

} // namespace Symbolid

namespace Java {

namespace Alpha {

struct DeclOfExecutableDefn : Predicate<std::tuple<ExecutableDefinition, Declaration>> {
  static const char* GLEAN_name() {
    return "java.alpha.DeclOfExecutableDefn";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclOfExecutableDefn

struct DeclOfDefn : Predicate<std::tuple<Definition, Declaration>> {
  static const char* GLEAN_name() {
    return "java.alpha.DeclOfDefn";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclOfDefn

struct ContainsDeclaration : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "java.alpha.ContainsDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ContainsDeclaration

struct ConstructorDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>, std::vector<Fact<ParameterDeclaration>>, std::vector<Fact<Annotation>>, std::vector<Modifier>, std::vector<Fact<TypeParam>>, std::vector<Fact<Type>>, Definition, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.ConstructorDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ConstructorDeclaration

struct ClassDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, std::vector<Modifier>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>>, std::vector<Fact<Type>>, std::vector<Fact<Annotation>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Definition>>, std::vector<Fact<TypeParam>>, facebook::glean::cpp::schema::Src::ByteSpan, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "java.alpha.ClassDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ClassDeclaration

} // namespace Alpha

} // namespace Java

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Java::Alpha::BaseType> {
  using Type = Sum<facebook::glean::cpp::schema::Java::Alpha::ObjectType, facebook::glean::cpp::schema::Java::Alpha::PrimitiveType, facebook::glean::cpp::schema::Java::Alpha::TypeVar, facebook::glean::cpp::schema::Java::Alpha::ArrayType>;
};


namespace schema {

namespace Java {

namespace Alpha {

struct BaseType {
  boost::variant<Alt<0, Fact<ObjectType>>, Alt<1, Fact<PrimitiveType>>, Alt<2, Fact<TypeVar>>, Alt<3, Fact<ArrayType>>> GLEAN_value;

  static BaseType object(const Fact<ObjectType>& a) {
    return BaseType{Alt<0, Fact<ObjectType>>(a)};
  }
  static BaseType primitive(const Fact<PrimitiveType>& a) {
    return BaseType{Alt<1, Fact<PrimitiveType>>(a)};
  }
  static BaseType variable(const Fact<TypeVar>& a) {
    return BaseType{Alt<2, Fact<TypeVar>>(a)};
  }
  static BaseType array(const Fact<ArrayType>& a) {
    return BaseType{Alt<3, Fact<ArrayType>>(a)};
  }

  bool operator==(const BaseType& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const BaseType& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const BaseType& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const BaseType& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const BaseType& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const BaseType& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<BaseType>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct BaseType

struct Type : Predicate<std::tuple<BaseType, std::vector<Fact<TypeArg>>, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Type>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.Type";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Type

struct ArrayType : Predicate<std::tuple<Fact<Type>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.ArrayType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ArrayType

struct Annotation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "java.alpha.Annotation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Annotation

struct AnnotatedClass : Predicate<std::tuple<Fact<Annotation>, Fact<ClassDeclaration>>> {
  static const char* GLEAN_name() {
    return "java.alpha.AnnotatedClass";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct AnnotatedClass

} // namespace Alpha

} // namespace Java

namespace Indexer {

struct Config : Predicate<std::string, std::string> {
  static const char* GLEAN_name() {
    return "indexer.Config";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Config

} // namespace Indexer

namespace Hs {

struct ValBind : Predicate<std::tuple<Fact<Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<SigDecl>>>>> {
  static const char* GLEAN_name() {
    return "hs.ValBind";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ValBind

struct UnitName : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "hs.UnitName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct UnitName

struct TypeSynDecl : Predicate<std::tuple<Fact<Name>>> {
  static const char* GLEAN_name() {
    return "hs.TypeSynDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct TypeSynDecl

struct TypeFamilyDecl : Predicate<std::tuple<Fact<Name>>> {
  static const char* GLEAN_name() {
    return "hs.TypeFamilyDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct TypeFamilyDecl

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hs::TypeArg> {
  using Type = Tuple<Bool, facebook::glean::cpp::schema::Hs::Type>;
};


namespace schema {

namespace Hs {

struct TypeArg {
  bool visible;
  Fact<Type> ty;

  bool operator==(const TypeArg& other) const {
    return std::tie(visible,ty)
             == std::tie(other.visible,other.ty);
  }
  bool operator!=(const TypeArg& other) const {
    return std::tie(visible,ty)
             != std::tie(other.visible,other.ty);
  }
  bool operator<(const TypeArg& other) const {
    return std::tie(visible,ty)
             < std::tie(other.visible,other.ty);
  }
  bool operator<=(const TypeArg& other) const {
    return std::tie(visible,ty)
             <= std::tie(other.visible,other.ty);
  }
  bool operator>(const TypeArg& other) const {
    return std::tie(visible,ty)
             > std::tie(other.visible,other.ty);
  }
  bool operator>=(const TypeArg& other) const {
    return std::tie(visible,ty)
             >= std::tie(other.visible,other.ty);
  }
  void outputRepr(Output<Repr<TypeArg>> out) const {
    outputValue(out, std::make_tuple(visible, ty));
  }
}; // struct TypeArg

struct TyVarBind : Predicate<std::tuple<Fact<Name>>> {
  static const char* GLEAN_name() {
    return "hs.TyVarBind";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct TyVarBind

using TyVar = std::string;

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hs::TupleSort> {
  using Type = Enum<3>;
};


namespace schema {

namespace Hs {

enum class TupleSort { boxed, unboxed, constraint };

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hs::TyConSort> {
  using Type = Sum<Tuple<>, Tuple<Nat, Repr<facebook::glean::cpp::schema::Hs::TupleSort>>, Tuple<Nat>, Tuple<>>;
};


namespace schema {

namespace Hs {

struct TyConSort {
  boost::variant<Alt<0, std::tuple<>>, Alt<1, std::tuple<uint64_t, TupleSort>>, Alt<2, std::tuple<uint64_t>>, Alt<3, std::tuple<>>> GLEAN_value;

  static TyConSort normal() {
    return TyConSort{Alt<0, std::tuple<>>(std::make_tuple())};
  }
  static TyConSort tuple(const uint64_t& arity, const TupleSort& sort) {
    return TyConSort{Alt<1, std::tuple<uint64_t, TupleSort>>(std::make_tuple(arity, sort))};
  }
  static TyConSort sum(const uint64_t& arity) {
    return TyConSort{Alt<2, std::tuple<uint64_t>>(std::make_tuple(arity))};
  }
  static TyConSort equality() {
    return TyConSort{Alt<3, std::tuple<>>(std::make_tuple())};
  }

  bool operator==(const TyConSort& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const TyConSort& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const TyConSort& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const TyConSort& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const TyConSort& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const TyConSort& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<TyConSort>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct TyConSort

struct TyCon : Predicate<std::tuple<Fact<Name>, TyConSort, bool>> {
  static const char* GLEAN_name() {
    return "hs.TyCon";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct TyCon

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hs::Specificity> {
  using Type = Enum<2>;
};


namespace schema {

namespace Hs {

enum class Specificity { inferred, specified };

struct SourceModule : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Module>>> {
  static const char* GLEAN_name() {
    return "hs.SourceModule";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SourceModule

struct SigDecl : Predicate<std::tuple<Fact<Name>, facebook::glean::cpp::schema::Src::FileLocation>> {
  static const char* GLEAN_name() {
    return "hs.SigDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SigDecl

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hs::RefTarget> {
  using Type = Sum<facebook::glean::cpp::schema::Hs::Name, facebook::glean::cpp::schema::Hs::ModuleName>;
};


namespace schema {

namespace Hs {

struct RefTarget {
  boost::variant<Alt<0, Fact<Name>>, Alt<1, Fact<ModuleName>>> GLEAN_value;

  static RefTarget name(const Fact<Name>& a) {
    return RefTarget{Alt<0, Fact<Name>>(a)};
  }
  static RefTarget modName(const Fact<ModuleName>& a) {
    return RefTarget{Alt<1, Fact<ModuleName>>(a)};
  }

  bool operator==(const RefTarget& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const RefTarget& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const RefTarget& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const RefTarget& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const RefTarget& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const RefTarget& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<RefTarget>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct RefTarget

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hs::RefKind> {
  using Type = Enum<5>;
};


namespace schema {

namespace Hs {

enum class RefKind { importref, exportref, coderef, tydecl, instbind };

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hs::RefSpan> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Hs::RefKind>, Repr<facebook::glean::cpp::schema::Src::ByteSpan>>;
};


namespace schema {

namespace Hs {

struct RefSpan {
  RefKind kind;
  facebook::glean::cpp::schema::Src::ByteSpan span;

  bool operator==(const RefSpan& other) const {
    return std::tie(kind,span)
             == std::tie(other.kind,other.span);
  }
  bool operator!=(const RefSpan& other) const {
    return std::tie(kind,span)
             != std::tie(other.kind,other.span);
  }
  bool operator<(const RefSpan& other) const {
    return std::tie(kind,span)
             < std::tie(other.kind,other.span);
  }
  bool operator<=(const RefSpan& other) const {
    return std::tie(kind,span)
             <= std::tie(other.kind,other.span);
  }
  bool operator>(const RefSpan& other) const {
    return std::tie(kind,span)
             > std::tie(other.kind,other.span);
  }
  bool operator>=(const RefSpan& other) const {
    return std::tie(kind,span)
             >= std::tie(other.kind,other.span);
  }
  void outputRepr(Output<Repr<RefSpan>> out) const {
    outputValue(out, std::make_tuple(kind, span));
  }
}; // struct RefSpan

struct XRef : Predicate<std::tuple<RefTarget, Fact<facebook::glean::cpp::schema::Src::File>, std::vector<RefSpan>>> {
  static const char* GLEAN_name() {
    return "hs.XRef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct XRef

struct RecordFieldDecl : Predicate<std::tuple<Fact<Name>, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "hs.RecordFieldDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct RecordFieldDecl

struct PatSynDecl : Predicate<std::tuple<Fact<Name>>> {
  static const char* GLEAN_name() {
    return "hs.PatSynDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct PatSynDecl

struct PatBind : Predicate<std::tuple<Fact<Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>>>> {
  static const char* GLEAN_name() {
    return "hs.PatBind";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct PatBind

struct OccNameLowerCase : Predicate<std::tuple<std::string, Fact<OccName>>> {
  static const char* GLEAN_name() {
    return "hs.OccNameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct OccNameLowerCase

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hs::Namespace> {
  using Type = Enum<4>;
};


namespace schema {

namespace Hs {

enum class Namespace { var_, datacon, tyvar, tycon };

struct OccName : Predicate<std::tuple<std::string, Namespace>> {
  static const char* GLEAN_name() {
    return "hs.OccName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct OccName

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hs::NameSort> {
  using Type = Sum<Tuple<>, Repr<facebook::glean::cpp::schema::Src::ByteSpan>>;
};


namespace schema {

namespace Hs {

struct NameSort {
  boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Src::ByteSpan>> GLEAN_value;

  static NameSort external() {
    return NameSort{Alt<0, std::tuple<>>(std::make_tuple())};
  }
  static NameSort internal(const facebook::glean::cpp::schema::Src::ByteSpan& a) {
    return NameSort{Alt<1, facebook::glean::cpp::schema::Src::ByteSpan>(a)};
  }

  bool operator==(const NameSort& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const NameSort& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const NameSort& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const NameSort& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const NameSort& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const NameSort& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<NameSort>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct NameSort

struct Name : Predicate<std::tuple<Fact<OccName>, Fact<Module>, NameSort>> {
  static const char* GLEAN_name() {
    return "hs.Name";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Name

struct ModuleSource : Predicate<std::tuple<Fact<Module>, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "hs.ModuleSource";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ModuleSource

struct ModuleName : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "hs.ModuleName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ModuleName

struct ModuleDeclarations : Predicate<std::tuple<Fact<Module>, std::set<Fact<Name>>, std::set<Fact<Name>>>> {
  static const char* GLEAN_name() {
    return "hs.ModuleDeclarations";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ModuleDeclarations

struct Module : Predicate<std::tuple<Fact<ModuleName>, Fact<UnitName>>> {
  static const char* GLEAN_name() {
    return "hs.Module";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Module

struct MethDecl : Predicate<std::tuple<Fact<Name>, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "hs.MethDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct MethDecl

struct LitType : Predicate<boost::variant<Alt<0, uint64_t>, Alt<1, std::string>, Alt<2, uint64_t>>> {
  static const char* GLEAN_name() {
    return "hs.LitType";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct LitType

struct InstanceDecl : Predicate<std::tuple<std::vector<Fact<InstanceBind>>, facebook::glean::cpp::schema::Src::FileLocation>> {
  static const char* GLEAN_name() {
    return "hs.InstanceDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct InstanceDecl

struct InstanceBindToDecl : Predicate<std::tuple<Fact<InstanceBind>, boost::variant<Alt<0, Fact<InstanceDecl>>, Alt<1, Fact<ClassDecl>>>>> {
  static const char* GLEAN_name() {
    return "hs.InstanceBindToDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct InstanceBindToDecl

struct InstanceBind : Predicate<std::tuple<Fact<Name>, facebook::glean::cpp::schema::Src::FileLocation>> {
  static const char* GLEAN_name() {
    return "hs.InstanceBind";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct InstanceBind

struct FileXRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::vector<Fact<XRef>>>> {
  static const char* GLEAN_name() {
    return "hs.FileXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FileXRefs

struct DeclarationLocation : Predicate<std::tuple<Fact<Name>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "hs.DeclarationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclarationLocation

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hs::Declaration> {
  using Type = Sum<facebook::glean::cpp::schema::Hs::ValBind, facebook::glean::cpp::schema::Hs::TypeFamilyDecl, facebook::glean::cpp::schema::Hs::TypeSynDecl, facebook::glean::cpp::schema::Hs::DataDecl, facebook::glean::cpp::schema::Hs::ConstrDecl, facebook::glean::cpp::schema::Hs::PatSynDecl, facebook::glean::cpp::schema::Hs::ClassDecl, facebook::glean::cpp::schema::Hs::MethDecl, facebook::glean::cpp::schema::Hs::InstanceDecl, facebook::glean::cpp::schema::Hs::PatBind, facebook::glean::cpp::schema::Hs::TyVarBind, facebook::glean::cpp::schema::Hs::RecordFieldDecl, facebook::glean::cpp::schema::Hs::SigDecl>;
};


namespace schema {

namespace Hs {

struct Declaration {
  boost::variant<Alt<0, Fact<ValBind>>, Alt<1, Fact<TypeFamilyDecl>>, Alt<2, Fact<TypeSynDecl>>, Alt<3, Fact<DataDecl>>, Alt<4, Fact<ConstrDecl>>, Alt<5, Fact<PatSynDecl>>, Alt<6, Fact<ClassDecl>>, Alt<7, Fact<MethDecl>>, Alt<8, Fact<InstanceDecl>>, Alt<9, Fact<PatBind>>, Alt<10, Fact<TyVarBind>>, Alt<11, Fact<RecordFieldDecl>>, Alt<12, Fact<SigDecl>>> GLEAN_value;

  static Declaration val(const Fact<ValBind>& a) {
    return Declaration{Alt<0, Fact<ValBind>>(a)};
  }
  static Declaration typeFamily(const Fact<TypeFamilyDecl>& a) {
    return Declaration{Alt<1, Fact<TypeFamilyDecl>>(a)};
  }
  static Declaration type_(const Fact<TypeSynDecl>& a) {
    return Declaration{Alt<2, Fact<TypeSynDecl>>(a)};
  }
  static Declaration data(const Fact<DataDecl>& a) {
    return Declaration{Alt<3, Fact<DataDecl>>(a)};
  }
  static Declaration con(const Fact<ConstrDecl>& a) {
    return Declaration{Alt<4, Fact<ConstrDecl>>(a)};
  }
  static Declaration patSyn(const Fact<PatSynDecl>& a) {
    return Declaration{Alt<5, Fact<PatSynDecl>>(a)};
  }
  static Declaration class_(const Fact<ClassDecl>& a) {
    return Declaration{Alt<6, Fact<ClassDecl>>(a)};
  }
  static Declaration method(const Fact<MethDecl>& a) {
    return Declaration{Alt<7, Fact<MethDecl>>(a)};
  }
  static Declaration instance(const Fact<InstanceDecl>& a) {
    return Declaration{Alt<8, Fact<InstanceDecl>>(a)};
  }
  static Declaration patBind(const Fact<PatBind>& a) {
    return Declaration{Alt<9, Fact<PatBind>>(a)};
  }
  static Declaration tyVarBind(const Fact<TyVarBind>& a) {
    return Declaration{Alt<10, Fact<TyVarBind>>(a)};
  }
  static Declaration field(const Fact<RecordFieldDecl>& a) {
    return Declaration{Alt<11, Fact<RecordFieldDecl>>(a)};
  }
  static Declaration sig(const Fact<SigDecl>& a) {
    return Declaration{Alt<12, Fact<SigDecl>>(a)};
  }

  bool operator==(const Declaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Declaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Declaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Declaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Declaration

struct DeclarationOfName : Predicate<std::tuple<Fact<Name>, Declaration>> {
  static const char* GLEAN_name() {
    return "hs.DeclarationOfName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclarationOfName

struct DeclarationSpan : Predicate<std::tuple<Declaration, facebook::glean::cpp::schema::Src::FileLocation>> {
  static const char* GLEAN_name() {
    return "hs.DeclarationSpan";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclarationSpan

struct DataDecl : Predicate<std::tuple<Fact<Name>, std::vector<Fact<ConstrDecl>>>> {
  static const char* GLEAN_name() {
    return "hs.DataDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DataDecl

struct ConstrDecl : Predicate<std::tuple<Fact<Name>, Fact<Name>, std::vector<Fact<RecordFieldDecl>>>> {
  static const char* GLEAN_name() {
    return "hs.ConstrDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ConstrDecl

struct ClassDecl : Predicate<std::tuple<Fact<Name>, std::vector<Fact<MethDecl>>, std::vector<Fact<InstanceBind>>>> {
  static const char* GLEAN_name() {
    return "hs.ClassDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ClassDecl

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hs::ArgFlag> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Hs::Specificity>, Tuple<>>;
};


namespace schema {

namespace Hs {

struct ArgFlag {
  boost::variant<Alt<0, Specificity>, Alt<1, std::tuple<>>> GLEAN_value;

  static ArgFlag invisible(const Specificity& a) {
    return ArgFlag{Alt<0, Specificity>(a)};
  }
  static ArgFlag requird() {
    return ArgFlag{Alt<1, std::tuple<>>(std::make_tuple())};
  }

  bool operator==(const ArgFlag& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const ArgFlag& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const ArgFlag& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const ArgFlag& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const ArgFlag& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const ArgFlag& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<ArgFlag>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct ArgFlag

struct Type : Predicate<boost::variant<Alt<0, TyVar>, Alt<1, std::tuple<Fact<Type>, std::vector<TypeArg>>>, Alt<2, std::tuple<Fact<TyCon>, std::vector<TypeArg>>>, Alt<3, std::tuple<TyVar, Fact<Type>, ArgFlag, Fact<Type>>>, Alt<4, std::tuple<Fact<Type>, Fact<Type>, Fact<Type>>>, Alt<5, std::tuple<Fact<Type>, Fact<Type>>>, Alt<6, Fact<LitType>>, Alt<7, Fact<Type>>, Alt<8, std::tuple<>>>> {
  static const char* GLEAN_name() {
    return "hs.Type";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Type

} // namespace Hs

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::Visibility> {
  using Type = Enum<4>;
};


namespace schema {

namespace Hack {

enum class Visibility { Private, Protected, Public, Internal };

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::Variance> {
  using Type = Enum<3>;
};


namespace schema {

namespace Hack {

enum class Variance { Contravariant, Covariant, Invariant };

struct UserAttribute : Predicate<std::tuple<Fact<Name>, std::vector<std::string>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<QName>>>>> {
  static const char* GLEAN_name() {
    return "hack.UserAttribute";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct UserAttribute

struct TypedefDeclaration : Predicate<std::tuple<Fact<QName>>> {
  static const char* GLEAN_name() {
    return "hack.TypedefDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct TypedefDeclaration

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::TypeConstKind> {
  using Type = Enum<3>;
};


namespace schema {

namespace Hack {

enum class TypeConstKind { Abstract, Concrete, PartiallyAbstract };

struct TypeConstDefinition : Predicate<std::tuple<Fact<TypeConstDeclaration>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>>, TypeConstKind, std::vector<Fact<UserAttribute>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeInfo>>>>> {
  static const char* GLEAN_name() {
    return "hack.TypeConstDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct TypeConstDefinition

struct Type : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "hack.Type";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Type

struct TraitDeclaration : Predicate<std::tuple<Fact<QName>>> {
  static const char* GLEAN_name() {
    return "hack.TraitDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct TraitDeclaration

struct StringLiteral : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "hack.StringLiteral";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct StringLiteral

struct SearchTypedefByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchTypedefByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchTypedefByLowerCaseName

struct SearchTypeConstByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchTypeConstByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchTypeConstByLowerCaseName

struct SearchTraitByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchTraitByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchTraitByLowerCaseName

struct SearchPropertyByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchPropertyByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchPropertyByLowerCaseName

struct SearchNamespaceByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchNamespaceByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchNamespaceByLowerCaseName

struct SearchModuleByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchModuleByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchModuleByLowerCaseName

struct SearchMethodByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchMethodByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchMethodByLowerCaseName

struct SearchInterfaceByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchInterfaceByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchInterfaceByLowerCaseName

struct SearchGlobalConstByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchGlobalConstByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchGlobalConstByLowerCaseName

struct SearchFunctionByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchFunctionByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchFunctionByLowerCaseName

struct SearchEnumeratorByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchEnumeratorByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchEnumeratorByLowerCaseName

struct SearchEnumByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchEnumByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchEnumByLowerCaseName

struct SearchClassConstByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchClassConstByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchClassConstByLowerCaseName

struct SearchClassByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "hack.SearchClassByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchClassByLowerCaseName

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::ReifyKind> {
  using Type = Enum<3>;
};


namespace schema {

namespace Hack {

enum class ReifyKind { Erased, Reified, SoftReified };

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::ReadonlyKind> {
  using Type = Enum<1>;
};


namespace schema {

namespace Hack {

enum class ReadonlyKind { Readonly };

struct QName : Predicate<std::tuple<Fact<Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>>> {
  static const char* GLEAN_name() {
    return "hack.QName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct QName

struct PropertyDefinition : Predicate<std::tuple<Fact<PropertyDeclaration>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>>, Visibility, bool, bool, bool, std::vector<Fact<UserAttribute>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeInfo>>>>> {
  static const char* GLEAN_name() {
    return "hack.PropertyDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct PropertyDefinition

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::Parameter> {
  using Type = Tuple<facebook::glean::cpp::schema::Hack::Name, Maybe<facebook::glean::cpp::schema::Hack::Type>, Bool, Bool, Maybe<String>, Array<facebook::glean::cpp::schema::Hack::UserAttribute>, Maybe<facebook::glean::cpp::schema::Hack::TypeInfo>, Maybe<Repr<facebook::glean::cpp::schema::Hack::ReadonlyKind>>>;
};


namespace schema {

namespace Hack {

struct Parameter {
  Fact<Name> name;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>> type;
  bool isInout;
  bool isVariadic;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>> defaultValue;
  std::vector<Fact<UserAttribute>> attributes;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeInfo>>> typeInfo;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, ReadonlyKind>> readonly;

  bool operator==(const Parameter& other) const {
    return std::tie(name,type,isInout,isVariadic,defaultValue,attributes,typeInfo,readonly)
             == std::tie(other.name,other.type,other.isInout,other.isVariadic,other.defaultValue,other.attributes,other.typeInfo,other.readonly);
  }
  bool operator!=(const Parameter& other) const {
    return std::tie(name,type,isInout,isVariadic,defaultValue,attributes,typeInfo,readonly)
             != std::tie(other.name,other.type,other.isInout,other.isVariadic,other.defaultValue,other.attributes,other.typeInfo,other.readonly);
  }
  bool operator<(const Parameter& other) const {
    return std::tie(name,type,isInout,isVariadic,defaultValue,attributes,typeInfo,readonly)
             < std::tie(other.name,other.type,other.isInout,other.isVariadic,other.defaultValue,other.attributes,other.typeInfo,other.readonly);
  }
  bool operator<=(const Parameter& other) const {
    return std::tie(name,type,isInout,isVariadic,defaultValue,attributes,typeInfo,readonly)
             <= std::tie(other.name,other.type,other.isInout,other.isVariadic,other.defaultValue,other.attributes,other.typeInfo,other.readonly);
  }
  bool operator>(const Parameter& other) const {
    return std::tie(name,type,isInout,isVariadic,defaultValue,attributes,typeInfo,readonly)
             > std::tie(other.name,other.type,other.isInout,other.isVariadic,other.defaultValue,other.attributes,other.typeInfo,other.readonly);
  }
  bool operator>=(const Parameter& other) const {
    return std::tie(name,type,isInout,isVariadic,defaultValue,attributes,typeInfo,readonly)
             >= std::tie(other.name,other.type,other.isInout,other.isVariadic,other.defaultValue,other.attributes,other.typeInfo,other.readonly);
  }
  void outputRepr(Output<Repr<Parameter>> out) const {
    outputValue(out, std::make_tuple(name, type, isInout, isVariadic, defaultValue, attributes, typeInfo, readonly));
  }
}; // struct Parameter

struct Signature : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>>, std::vector<Parameter>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::vector<Fact<Context_>>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeInfo>>>>> {
  static const char* GLEAN_name() {
    return "hack.Signature";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Signature

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::Occurrence> {
  using Type = Sum<facebook::glean::cpp::schema::Hack::MethodOccurrence>;
};


namespace schema {

namespace Hack {

struct Occurrence {
  boost::variant<Alt<0, Fact<MethodOccurrence>>> GLEAN_value;

  static Occurrence method(const Fact<MethodOccurrence>& a) {
    return Occurrence{Alt<0, Fact<MethodOccurrence>>(a)};
  }

  bool operator==(const Occurrence& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Occurrence& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Occurrence& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Occurrence& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Occurrence& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Occurrence& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Occurrence>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Occurrence

struct NamespaceQName : Predicate<std::tuple<Fact<Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>>> {
  static const char* GLEAN_name() {
    return "hack.NamespaceQName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct NamespaceQName

struct NamespaceDeclaration : Predicate<std::tuple<Fact<NamespaceQName>>> {
  static const char* GLEAN_name() {
    return "hack.NamespaceDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct NamespaceDeclaration

struct NameLowerCase : Predicate<std::tuple<std::string, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "hack.NameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct NameLowerCase

struct Name : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "hack.Name";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Name

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::ModuleMembership> {
  using Type = Tuple<facebook::glean::cpp::schema::Hack::ModuleDeclaration, Bool>;
};


namespace schema {

namespace Hack {

struct ModuleMembership {
  Fact<ModuleDeclaration> declaration;
  bool internal;

  bool operator==(const ModuleMembership& other) const {
    return std::tie(declaration,internal)
             == std::tie(other.declaration,other.internal);
  }
  bool operator!=(const ModuleMembership& other) const {
    return std::tie(declaration,internal)
             != std::tie(other.declaration,other.internal);
  }
  bool operator<(const ModuleMembership& other) const {
    return std::tie(declaration,internal)
             < std::tie(other.declaration,other.internal);
  }
  bool operator<=(const ModuleMembership& other) const {
    return std::tie(declaration,internal)
             <= std::tie(other.declaration,other.internal);
  }
  bool operator>(const ModuleMembership& other) const {
    return std::tie(declaration,internal)
             > std::tie(other.declaration,other.internal);
  }
  bool operator>=(const ModuleMembership& other) const {
    return std::tie(declaration,internal)
             >= std::tie(other.declaration,other.internal);
  }
  void outputRepr(Output<Repr<ModuleMembership>> out) const {
    outputValue(out, std::make_tuple(declaration, internal));
  }
}; // struct ModuleMembership

struct ModuleDefinition : Predicate<std::tuple<Fact<ModuleDeclaration>, std::vector<Fact<UserAttribute>>>> {
  static const char* GLEAN_name() {
    return "hack.ModuleDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ModuleDefinition

struct ModuleDeclaration : Predicate<std::tuple<Fact<Name>>> {
  static const char* GLEAN_name() {
    return "hack.ModuleDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ModuleDeclaration

struct MethodOverrides : Predicate<std::tuple<Fact<MethodDeclaration>, Fact<MethodDeclaration>, boost::variant<Alt<0, std::tuple<>>, Alt<1, bool>>>> {
  static const char* GLEAN_name() {
    return "hack.MethodOverrides";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct MethodOverrides

struct MethodOverridden : Predicate<std::tuple<Fact<MethodDeclaration>, Fact<MethodDeclaration>, boost::variant<Alt<0, std::tuple<>>, Alt<1, bool>>>> {
  static const char* GLEAN_name() {
    return "hack.MethodOverridden";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct MethodOverridden

struct MethodOccurrence : Predicate<std::tuple<Fact<Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Name>>>>> {
  static const char* GLEAN_name() {
    return "hack.MethodOccurrence";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct MethodOccurrence

struct InterfaceDeclaration : Predicate<std::tuple<Fact<QName>>> {
  static const char* GLEAN_name() {
    return "hack.InterfaceDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct InterfaceDeclaration

struct IndexerInputsHash : Predicate<std::string, std::vector<uint8_t>> {
  static const char* GLEAN_name() {
    return "hack.IndexerInputsHash";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct IndexerInputsHash

struct GlobalNamespaceAlias : Predicate<std::tuple<Fact<Name>, Fact<NamespaceQName>>> {
  static const char* GLEAN_name() {
    return "hack.GlobalNamespaceAlias";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct GlobalNamespaceAlias

struct GlobalConstDefinition : Predicate<std::tuple<Fact<GlobalConstDeclaration>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>>, std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeInfo>>>>> {
  static const char* GLEAN_name() {
    return "hack.GlobalConstDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct GlobalConstDefinition

struct GlobalConstDeclaration : Predicate<std::tuple<Fact<QName>>> {
  static const char* GLEAN_name() {
    return "hack.GlobalConstDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct GlobalConstDeclaration

struct FunctionDeclaration : Predicate<std::tuple<Fact<QName>>> {
  static const char* GLEAN_name() {
    return "hack.FunctionDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct FunctionDeclaration

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::FieldClassConst> {
  using Type = Tuple<facebook::glean::cpp::schema::Hack::QName, facebook::glean::cpp::schema::Hack::Name>;
};


namespace schema {

namespace Hack {

struct FieldClassConst {
  Fact<QName> container;
  Fact<Name> name;

  bool operator==(const FieldClassConst& other) const {
    return std::tie(container,name)
             == std::tie(other.container,other.name);
  }
  bool operator!=(const FieldClassConst& other) const {
    return std::tie(container,name)
             != std::tie(other.container,other.name);
  }
  bool operator<(const FieldClassConst& other) const {
    return std::tie(container,name)
             < std::tie(other.container,other.name);
  }
  bool operator<=(const FieldClassConst& other) const {
    return std::tie(container,name)
             <= std::tie(other.container,other.name);
  }
  bool operator>(const FieldClassConst& other) const {
    return std::tie(container,name)
             > std::tie(other.container,other.name);
  }
  bool operator>=(const FieldClassConst& other) const {
    return std::tie(container,name)
             >= std::tie(other.container,other.name);
  }
  void outputRepr(Output<Repr<FieldClassConst>> out) const {
    outputValue(out, std::make_tuple(container, name));
  }
}; // struct FieldClassConst

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::ShapeKV> {
  using Type = Tuple<Sum<String, String, Repr<facebook::glean::cpp::schema::Hack::FieldClassConst>>, facebook::glean::cpp::schema::Hack::Hint, Bool>;
};


namespace schema {

namespace Hack {

struct ShapeKV {
  boost::variant<Alt<0, std::string>, Alt<1, std::string>, Alt<2, FieldClassConst>> key;
  Fact<Hint> value;
  bool opt;

  bool operator==(const ShapeKV& other) const {
    return std::tie(key,value,opt)
             == std::tie(other.key,other.value,other.opt);
  }
  bool operator!=(const ShapeKV& other) const {
    return std::tie(key,value,opt)
             != std::tie(other.key,other.value,other.opt);
  }
  bool operator<(const ShapeKV& other) const {
    return std::tie(key,value,opt)
             < std::tie(other.key,other.value,other.opt);
  }
  bool operator<=(const ShapeKV& other) const {
    return std::tie(key,value,opt)
             <= std::tie(other.key,other.value,other.opt);
  }
  bool operator>(const ShapeKV& other) const {
    return std::tie(key,value,opt)
             > std::tie(other.key,other.value,other.opt);
  }
  bool operator>=(const ShapeKV& other) const {
    return std::tie(key,value,opt)
             >= std::tie(other.key,other.value,other.opt);
  }
  void outputRepr(Output<Repr<ShapeKV>> out) const {
    outputValue(out, std::make_tuple(key, value, opt));
  }
}; // struct ShapeKV

struct Hint : Predicate<boost::variant<Alt<0, std::tuple<Fact<QName>, std::vector<Fact<Hint>>>>, Alt<1, Fact<Hint>>, Alt<2, Fact<Hint>>, Alt<3, std::tuple<std::vector<Fact<Hint>>, std::vector<Fact<Hint>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Hint>>>>>, Alt<4, Fact<Hint>>, Alt<5, std::tuple<bool, std::vector<ShapeKV>>>, Alt<6, Fact<Hint>>, Alt<7, std::vector<Fact<Hint>>>, Alt<8, std::vector<Fact<Hint>>>, Alt<9, std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Hint>>>, Fact<Hint>>>, Alt<10, Fact<Type>>, Alt<11, std::string>, Alt<12, std::string>, Alt<13, std::tuple<>>, Alt<14, std::tuple<>>, Alt<15, std::tuple<>>, Alt<16, std::tuple<>>, Alt<17, std::tuple<>>, Alt<18, std::tuple<>>, Alt<19, Fact<Type>>>> {
  static const char* GLEAN_name() {
    return "hack.Hint";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Hint

struct Enumerator : Predicate<std::tuple<Fact<Name>, Fact<EnumDeclaration>>> {
  static const char* GLEAN_name() {
    return "hack.Enumerator";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Enumerator

struct EnumDefinition : Predicate<std::tuple<Fact<EnumDeclaration>, Fact<Type>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeInfo>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeInfo>>>, std::vector<Fact<Enumerator>>, std::vector<Fact<UserAttribute>>, std::vector<Fact<EnumDeclaration>>, bool, boost::variant<Alt<0, std::tuple<>>, Alt<1, ModuleMembership>>>> {
  static const char* GLEAN_name() {
    return "hack.EnumDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct EnumDefinition

struct EnumDeclaration : Predicate<std::tuple<Fact<QName>>> {
  static const char* GLEAN_name() {
    return "hack.EnumDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct EnumDeclaration

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::Definition> {
  using Type = Sum<facebook::glean::cpp::schema::Hack::ClassDefinition, facebook::glean::cpp::schema::Hack::ClassConstDefinition, facebook::glean::cpp::schema::Hack::EnumDefinition, facebook::glean::cpp::schema::Hack::FunctionDefinition, facebook::glean::cpp::schema::Hack::GlobalConstDefinition, facebook::glean::cpp::schema::Hack::InterfaceDefinition, facebook::glean::cpp::schema::Hack::TraitDefinition, facebook::glean::cpp::schema::Hack::MethodDefinition, facebook::glean::cpp::schema::Hack::PropertyDefinition, facebook::glean::cpp::schema::Hack::TypeConstDefinition, facebook::glean::cpp::schema::Hack::TypedefDefinition, facebook::glean::cpp::schema::Hack::ModuleDefinition>;
};


namespace schema {

namespace Hack {

struct Definition {
  boost::variant<Alt<0, Fact<ClassDefinition>>, Alt<1, Fact<ClassConstDefinition>>, Alt<2, Fact<EnumDefinition>>, Alt<3, Fact<FunctionDefinition>>, Alt<4, Fact<GlobalConstDefinition>>, Alt<5, Fact<InterfaceDefinition>>, Alt<6, Fact<TraitDefinition>>, Alt<7, Fact<MethodDefinition>>, Alt<8, Fact<PropertyDefinition>>, Alt<9, Fact<TypeConstDefinition>>, Alt<10, Fact<TypedefDefinition>>, Alt<11, Fact<ModuleDefinition>>> GLEAN_value;

  static Definition class_(const Fact<ClassDefinition>& a) {
    return Definition{Alt<0, Fact<ClassDefinition>>(a)};
  }
  static Definition classConst(const Fact<ClassConstDefinition>& a) {
    return Definition{Alt<1, Fact<ClassConstDefinition>>(a)};
  }
  static Definition enum_(const Fact<EnumDefinition>& a) {
    return Definition{Alt<2, Fact<EnumDefinition>>(a)};
  }
  static Definition function_(const Fact<FunctionDefinition>& a) {
    return Definition{Alt<3, Fact<FunctionDefinition>>(a)};
  }
  static Definition globalConst(const Fact<GlobalConstDefinition>& a) {
    return Definition{Alt<4, Fact<GlobalConstDefinition>>(a)};
  }
  static Definition interface_(const Fact<InterfaceDefinition>& a) {
    return Definition{Alt<5, Fact<InterfaceDefinition>>(a)};
  }
  static Definition trait(const Fact<TraitDefinition>& a) {
    return Definition{Alt<6, Fact<TraitDefinition>>(a)};
  }
  static Definition method(const Fact<MethodDefinition>& a) {
    return Definition{Alt<7, Fact<MethodDefinition>>(a)};
  }
  static Definition property_(const Fact<PropertyDefinition>& a) {
    return Definition{Alt<8, Fact<PropertyDefinition>>(a)};
  }
  static Definition typeConst(const Fact<TypeConstDefinition>& a) {
    return Definition{Alt<9, Fact<TypeConstDefinition>>(a)};
  }
  static Definition typedef_(const Fact<TypedefDefinition>& a) {
    return Definition{Alt<10, Fact<TypedefDefinition>>(a)};
  }
  static Definition module(const Fact<ModuleDefinition>& a) {
    return Definition{Alt<11, Fact<ModuleDefinition>>(a)};
  }

  bool operator==(const Definition& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Definition& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Definition& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Definition& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Definition& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Definition& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Definition>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Definition

struct Context_ : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "hack.Context_";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Context_

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::ContainerDeclaration> {
  using Type = Sum<facebook::glean::cpp::schema::Hack::ClassDeclaration, facebook::glean::cpp::schema::Hack::EnumDeclaration, facebook::glean::cpp::schema::Hack::InterfaceDeclaration, facebook::glean::cpp::schema::Hack::TraitDeclaration>;
};


namespace schema {

namespace Hack {

struct ContainerDeclaration {
  boost::variant<Alt<0, Fact<ClassDeclaration>>, Alt<1, Fact<EnumDeclaration>>, Alt<2, Fact<InterfaceDeclaration>>, Alt<3, Fact<TraitDeclaration>>> GLEAN_value;

  static ContainerDeclaration class_(const Fact<ClassDeclaration>& a) {
    return ContainerDeclaration{Alt<0, Fact<ClassDeclaration>>(a)};
  }
  static ContainerDeclaration enum_(const Fact<EnumDeclaration>& a) {
    return ContainerDeclaration{Alt<1, Fact<EnumDeclaration>>(a)};
  }
  static ContainerDeclaration interface_(const Fact<InterfaceDeclaration>& a) {
    return ContainerDeclaration{Alt<2, Fact<InterfaceDeclaration>>(a)};
  }
  static ContainerDeclaration trait(const Fact<TraitDeclaration>& a) {
    return ContainerDeclaration{Alt<3, Fact<TraitDeclaration>>(a)};
  }

  bool operator==(const ContainerDeclaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const ContainerDeclaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const ContainerDeclaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const ContainerDeclaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const ContainerDeclaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const ContainerDeclaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<ContainerDeclaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct ContainerDeclaration

struct ContainerDeclarationQName : Predicate<ContainerDeclaration, Fact<QName>> {
  static const char* GLEAN_name() {
    return "hack.ContainerDeclarationQName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ContainerDeclarationQName

struct ContainerParent : Predicate<std::tuple<ContainerDeclaration, ContainerDeclaration>> {
  static const char* GLEAN_name() {
    return "hack.ContainerParent";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ContainerParent

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::Declaration> {
  using Type = Sum<facebook::glean::cpp::schema::Hack::ClassConstDeclaration, Repr<facebook::glean::cpp::schema::Hack::ContainerDeclaration>, facebook::glean::cpp::schema::Hack::Enumerator, facebook::glean::cpp::schema::Hack::FunctionDeclaration, facebook::glean::cpp::schema::Hack::GlobalConstDeclaration, facebook::glean::cpp::schema::Hack::NamespaceDeclaration, facebook::glean::cpp::schema::Hack::MethodDeclaration, facebook::glean::cpp::schema::Hack::PropertyDeclaration, facebook::glean::cpp::schema::Hack::TypeConstDeclaration, facebook::glean::cpp::schema::Hack::TypedefDeclaration, facebook::glean::cpp::schema::Hack::ModuleDeclaration>;
};


namespace schema {

namespace Hack {

struct Declaration {
  boost::variant<Alt<0, Fact<ClassConstDeclaration>>, Alt<1, ContainerDeclaration>, Alt<2, Fact<Enumerator>>, Alt<3, Fact<FunctionDeclaration>>, Alt<4, Fact<GlobalConstDeclaration>>, Alt<5, Fact<NamespaceDeclaration>>, Alt<6, Fact<MethodDeclaration>>, Alt<7, Fact<PropertyDeclaration>>, Alt<8, Fact<TypeConstDeclaration>>, Alt<9, Fact<TypedefDeclaration>>, Alt<10, Fact<ModuleDeclaration>>> GLEAN_value;

  static Declaration classConst(const Fact<ClassConstDeclaration>& a) {
    return Declaration{Alt<0, Fact<ClassConstDeclaration>>(a)};
  }
  static Declaration container(const ContainerDeclaration& a) {
    return Declaration{Alt<1, ContainerDeclaration>(a)};
  }
  static Declaration enumerator(const Fact<Enumerator>& a) {
    return Declaration{Alt<2, Fact<Enumerator>>(a)};
  }
  static Declaration function_(const Fact<FunctionDeclaration>& a) {
    return Declaration{Alt<3, Fact<FunctionDeclaration>>(a)};
  }
  static Declaration globalConst(const Fact<GlobalConstDeclaration>& a) {
    return Declaration{Alt<4, Fact<GlobalConstDeclaration>>(a)};
  }
  static Declaration namespace_(const Fact<NamespaceDeclaration>& a) {
    return Declaration{Alt<5, Fact<NamespaceDeclaration>>(a)};
  }
  static Declaration method(const Fact<MethodDeclaration>& a) {
    return Declaration{Alt<6, Fact<MethodDeclaration>>(a)};
  }
  static Declaration property_(const Fact<PropertyDeclaration>& a) {
    return Declaration{Alt<7, Fact<PropertyDeclaration>>(a)};
  }
  static Declaration typeConst(const Fact<TypeConstDeclaration>& a) {
    return Declaration{Alt<8, Fact<TypeConstDeclaration>>(a)};
  }
  static Declaration typedef_(const Fact<TypedefDeclaration>& a) {
    return Declaration{Alt<9, Fact<TypedefDeclaration>>(a)};
  }
  static Declaration module(const Fact<ModuleDeclaration>& a) {
    return Declaration{Alt<10, Fact<ModuleDeclaration>>(a)};
  }

  bool operator==(const Declaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Declaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Declaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Declaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Declaration

struct DeclarationComment : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "hack.DeclarationComment";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct DeclarationComment

struct DeclarationLocation : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "hack.DeclarationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct DeclarationLocation

struct DeclarationName : Predicate<Declaration, Fact<Name>> {
  static const char* GLEAN_name() {
    return "hack.DeclarationName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct DeclarationName

struct DeclarationNamespace : Predicate<std::tuple<Declaration, Fact<NamespaceQName>>> {
  static const char* GLEAN_name() {
    return "hack.DeclarationNamespace";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct DeclarationNamespace

struct DeclarationSource : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.DeclarationSource";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct DeclarationSource

struct DeclarationSpan : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "hack.DeclarationSpan";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct DeclarationSpan

struct DeclarationTarget : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.DeclarationTarget";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct DeclarationTarget

struct FileDeclarations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::vector<Declaration>>> {
  static const char* GLEAN_name() {
    return "hack.FileDeclarations";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct FileDeclarations

struct MemberCluster : Predicate<std::tuple<std::vector<Declaration>>> {
  static const char* GLEAN_name() {
    return "hack.MemberCluster";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct MemberCluster

struct ModuleChild : Predicate<std::tuple<Fact<ModuleDeclaration>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.ModuleChild";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ModuleChild

struct ModuleParent : Predicate<std::tuple<Declaration, Fact<ModuleDeclaration>>> {
  static const char* GLEAN_name() {
    return "hack.ModuleParent";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ModuleParent

struct NamespaceMember : Predicate<std::tuple<Fact<NamespaceQName>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.NamespaceMember";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct NamespaceMember

struct SearchClassByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchClassByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchClassByName

struct SearchClassConstByName : Predicate<std::tuple<std::string, Fact<QName>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchClassConstByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchClassConstByName

struct SearchEnumByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchEnumByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchEnumByName

struct SearchEnumeratorByName : Predicate<std::tuple<std::string, Fact<QName>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchEnumeratorByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchEnumeratorByName

struct SearchFunctionByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchFunctionByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchFunctionByName

struct SearchGlobalConstByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchGlobalConstByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchGlobalConstByName

struct SearchInterfaceByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchInterfaceByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchInterfaceByName

struct SearchMethodByName : Predicate<std::tuple<std::string, Fact<QName>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchMethodByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchMethodByName

struct SearchModuleByName : Predicate<std::tuple<std::string, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchModuleByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchModuleByName

struct SearchNamespaceByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchNamespaceByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchNamespaceByName

struct SearchPropertyByName : Predicate<std::tuple<std::string, Fact<QName>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchPropertyByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchPropertyByName

struct SearchTraitByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchTraitByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchTraitByName

struct SearchTypeConstByName : Predicate<std::tuple<std::string, Fact<QName>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchTypeConstByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchTypeConstByName

struct SearchTypedefByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.SearchTypedefByName";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SearchTypedefByName

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::XRefTarget> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Hack::Declaration>, Repr<facebook::glean::cpp::schema::Hack::Occurrence>>;
};


namespace schema {

namespace Hack {

struct XRefTarget {
  boost::variant<Alt<0, Declaration>, Alt<1, Occurrence>> GLEAN_value;

  static XRefTarget declaration(const Declaration& a) {
    return XRefTarget{Alt<0, Declaration>(a)};
  }
  static XRefTarget occurrence(const Occurrence& a) {
    return XRefTarget{Alt<1, Occurrence>(a)};
  }

  bool operator==(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<XRefTarget>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct XRefTarget

struct TargetUses : Predicate<std::tuple<XRefTarget, Fact<facebook::glean::cpp::schema::Src::File>, std::vector<facebook::glean::cpp::schema::Src::RelByteSpan>>> {
  static const char* GLEAN_name() {
    return "hack.TargetUses";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct TargetUses

struct TargetUsesAbs : Predicate<std::tuple<XRefTarget, Fact<facebook::glean::cpp::schema::Src::File>, std::vector<facebook::glean::cpp::schema::Src::ByteSpan>>> {
  static const char* GLEAN_name() {
    return "hack.TargetUsesAbs";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct TargetUsesAbs

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::XRef> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Hack::XRefTarget>, Array<Repr<facebook::glean::cpp::schema::Src::RelByteSpan>>>;
};


namespace schema {

namespace Hack {

struct XRef {
  XRefTarget target;
  std::vector<facebook::glean::cpp::schema::Src::RelByteSpan> ranges;

  bool operator==(const XRef& other) const {
    return std::tie(target,ranges)
             == std::tie(other.target,other.ranges);
  }
  bool operator!=(const XRef& other) const {
    return std::tie(target,ranges)
             != std::tie(other.target,other.ranges);
  }
  bool operator<(const XRef& other) const {
    return std::tie(target,ranges)
             < std::tie(other.target,other.ranges);
  }
  bool operator<=(const XRef& other) const {
    return std::tie(target,ranges)
             <= std::tie(other.target,other.ranges);
  }
  bool operator>(const XRef& other) const {
    return std::tie(target,ranges)
             > std::tie(other.target,other.ranges);
  }
  bool operator>=(const XRef& other) const {
    return std::tie(target,ranges)
             >= std::tie(other.target,other.ranges);
  }
  void outputRepr(Output<Repr<XRef>> out) const {
    outputValue(out, std::make_tuple(target, ranges));
  }
}; // struct XRef

struct FileXRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::set<XRef>>> {
  static const char* GLEAN_name() {
    return "hack.FileXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct FileXRefs

struct TypeInfo : Predicate<std::tuple<Fact<Type>, std::vector<XRef>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Hint>>>>> {
  static const char* GLEAN_name() {
    return "hack.TypeInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct TypeInfo

} // namespace Hack

namespace Search {

namespace Hack {

struct SearchByName : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchByName

struct SearchFunctionInNamespace : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchFunctionInNamespace";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchFunctionInNamespace

struct SearchGlobalConstInNamespace : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchGlobalConstInNamespace";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchGlobalConstInNamespace

struct SearchInContainer : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchInContainer";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchInContainer

struct SearchInContainerNoProperty : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchInContainerNoProperty";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchInContainerNoProperty

struct SearchInContainerOrEnum : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchInContainerOrEnum";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchInContainerOrEnum

struct SearchInContainerOrEnumNoProperty : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchInContainerOrEnumNoProperty";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchInContainerOrEnumNoProperty

struct SearchInEnum : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchInEnum";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchInEnum

struct SearchInNamespace : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchInNamespace";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchInNamespace

struct SearchModule : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchModule";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchModule

struct SearchNamespace : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchNamespace";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchNamespace

struct SearchNamespacedDecl : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchNamespacedDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchNamespacedDecl

struct SearchPropertyInContainer : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchPropertyInContainer";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchPropertyInContainer

struct SearchTypeInNamespace : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "search.hack.SearchTypeInNamespace";
  }

  static constexpr size_t GLEAN_version() {
     return 7;
  }
}; // struct SearchTypeInNamespace

} // namespace Hack

} // namespace Search

namespace Hack {

struct InheritedMembers : Predicate<std::tuple<ContainerDeclaration, std::vector<Fact<MemberCluster>>>> {
  static const char* GLEAN_name() {
    return "hack.InheritedMembers";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct InheritedMembers

struct MethodDeclaration : Predicate<std::tuple<Fact<Name>, ContainerDeclaration>> {
  static const char* GLEAN_name() {
    return "hack.MethodDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct MethodDeclaration

struct PropertyDeclaration : Predicate<std::tuple<Fact<Name>, ContainerDeclaration>> {
  static const char* GLEAN_name() {
    return "hack.PropertyDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct PropertyDeclaration

struct TypeConstDeclaration : Predicate<std::tuple<Fact<Name>, ContainerDeclaration>> {
  static const char* GLEAN_name() {
    return "hack.TypeConstDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct TypeConstDeclaration

struct ContainerChild : Predicate<std::tuple<ContainerDeclaration, ContainerDeclaration>> {
  static const char* GLEAN_name() {
    return "hack.ContainerChild";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ContainerChild

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::ConstraintKind> {
  using Type = Enum<3>;
};


namespace schema {

namespace Hack {

enum class ConstraintKind { As, Equal, Super };

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::Constraint> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Hack::ConstraintKind>, facebook::glean::cpp::schema::Hack::Type, Maybe<facebook::glean::cpp::schema::Hack::TypeInfo>>;
};


namespace schema {

namespace Hack {

struct Constraint {
  ConstraintKind constraintKind;
  Fact<Type> type;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeInfo>>> typeInfo;

  bool operator==(const Constraint& other) const {
    return std::tie(constraintKind,type,typeInfo)
             == std::tie(other.constraintKind,other.type,other.typeInfo);
  }
  bool operator!=(const Constraint& other) const {
    return std::tie(constraintKind,type,typeInfo)
             != std::tie(other.constraintKind,other.type,other.typeInfo);
  }
  bool operator<(const Constraint& other) const {
    return std::tie(constraintKind,type,typeInfo)
             < std::tie(other.constraintKind,other.type,other.typeInfo);
  }
  bool operator<=(const Constraint& other) const {
    return std::tie(constraintKind,type,typeInfo)
             <= std::tie(other.constraintKind,other.type,other.typeInfo);
  }
  bool operator>(const Constraint& other) const {
    return std::tie(constraintKind,type,typeInfo)
             > std::tie(other.constraintKind,other.type,other.typeInfo);
  }
  bool operator>=(const Constraint& other) const {
    return std::tie(constraintKind,type,typeInfo)
             >= std::tie(other.constraintKind,other.type,other.typeInfo);
  }
  void outputRepr(Output<Repr<Constraint>> out) const {
    outputValue(out, std::make_tuple(constraintKind, type, typeInfo));
  }
}; // struct Constraint

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::TypeParameter> {
  using Type = Tuple<facebook::glean::cpp::schema::Hack::Name, Repr<facebook::glean::cpp::schema::Hack::Variance>, Repr<facebook::glean::cpp::schema::Hack::ReifyKind>, Array<Repr<facebook::glean::cpp::schema::Hack::Constraint>>, Array<facebook::glean::cpp::schema::Hack::UserAttribute>>;
};


namespace schema {

namespace Hack {

struct TypeParameter {
  Fact<Name> name;
  Variance variance;
  ReifyKind reifyKind;
  std::vector<Constraint> constraints;
  std::vector<Fact<UserAttribute>> attributes;

  bool operator==(const TypeParameter& other) const {
    return std::tie(name,variance,reifyKind,constraints,attributes)
             == std::tie(other.name,other.variance,other.reifyKind,other.constraints,other.attributes);
  }
  bool operator!=(const TypeParameter& other) const {
    return std::tie(name,variance,reifyKind,constraints,attributes)
             != std::tie(other.name,other.variance,other.reifyKind,other.constraints,other.attributes);
  }
  bool operator<(const TypeParameter& other) const {
    return std::tie(name,variance,reifyKind,constraints,attributes)
             < std::tie(other.name,other.variance,other.reifyKind,other.constraints,other.attributes);
  }
  bool operator<=(const TypeParameter& other) const {
    return std::tie(name,variance,reifyKind,constraints,attributes)
             <= std::tie(other.name,other.variance,other.reifyKind,other.constraints,other.attributes);
  }
  bool operator>(const TypeParameter& other) const {
    return std::tie(name,variance,reifyKind,constraints,attributes)
             > std::tie(other.name,other.variance,other.reifyKind,other.constraints,other.attributes);
  }
  bool operator>=(const TypeParameter& other) const {
    return std::tie(name,variance,reifyKind,constraints,attributes)
             >= std::tie(other.name,other.variance,other.reifyKind,other.constraints,other.attributes);
  }
  void outputRepr(Output<Repr<TypeParameter>> out) const {
    outputValue(out, std::make_tuple(name, variance, reifyKind, constraints, attributes));
  }
}; // struct TypeParameter

struct FunctionDefinition : Predicate<std::tuple<Fact<FunctionDeclaration>, Fact<Signature>, bool, std::vector<Fact<UserAttribute>>, std::vector<TypeParameter>, boost::variant<Alt<0, std::tuple<>>, Alt<1, ModuleMembership>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, ReadonlyKind>>>> {
  static const char* GLEAN_name() {
    return "hack.FunctionDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct FunctionDefinition

struct InterfaceDefinition : Predicate<std::tuple<Fact<InterfaceDeclaration>, std::vector<Declaration>, std::vector<Fact<InterfaceDeclaration>>, std::vector<Fact<UserAttribute>>, std::vector<TypeParameter>, std::vector<Fact<ClassDeclaration>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, ModuleMembership>>>> {
  static const char* GLEAN_name() {
    return "hack.InterfaceDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct InterfaceDefinition

struct MethodDefinition : Predicate<std::tuple<Fact<MethodDeclaration>, Fact<Signature>, Visibility, bool, bool, bool, bool, std::vector<Fact<UserAttribute>>, std::vector<TypeParameter>, boost::variant<Alt<0, std::tuple<>>, Alt<1, bool>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, ReadonlyKind>>>> {
  static const char* GLEAN_name() {
    return "hack.MethodDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct MethodDefinition

struct TraitDefinition : Predicate<std::tuple<Fact<TraitDeclaration>, std::vector<Declaration>, std::vector<Fact<InterfaceDeclaration>>, std::vector<Fact<TraitDeclaration>>, std::vector<Fact<UserAttribute>>, std::vector<TypeParameter>, std::vector<Fact<ClassDeclaration>>, std::vector<Fact<InterfaceDeclaration>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, ModuleMembership>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::vector<Fact<ClassDeclaration>>>>>> {
  static const char* GLEAN_name() {
    return "hack.TraitDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct TraitDefinition

struct TypedefDefinition : Predicate<std::tuple<Fact<TypedefDeclaration>, bool, std::vector<Fact<UserAttribute>>, std::vector<TypeParameter>, boost::variant<Alt<0, std::tuple<>>, Alt<1, ModuleMembership>>>> {
  static const char* GLEAN_name() {
    return "hack.TypedefDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct TypedefDefinition

struct ClassDefinition : Predicate<std::tuple<Fact<ClassDeclaration>, bool, bool, std::vector<Declaration>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<ClassDeclaration>>>, std::vector<Fact<InterfaceDeclaration>>, std::vector<Fact<TraitDeclaration>>, std::vector<Fact<UserAttribute>>, std::vector<TypeParameter>, boost::variant<Alt<0, std::tuple<>>, Alt<1, ModuleMembership>>>> {
  static const char* GLEAN_name() {
    return "hack.ClassDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ClassDefinition

struct ClassDeclaration : Predicate<std::tuple<Fact<QName>>> {
  static const char* GLEAN_name() {
    return "hack.ClassDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ClassDeclaration

struct ClassConstDefinition : Predicate<std::tuple<Fact<ClassConstDeclaration>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeInfo>>>>> {
  static const char* GLEAN_name() {
    return "hack.ClassConstDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ClassConstDefinition

struct ClassConstDeclaration : Predicate<std::tuple<Fact<Name>, ContainerDeclaration>> {
  static const char* GLEAN_name() {
    return "hack.ClassConstDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ClassConstDeclaration

struct AttributeToDefinition : Predicate<std::tuple<Fact<UserAttribute>, Definition>> {
  static const char* GLEAN_name() {
    return "hack.AttributeToDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct AttributeToDefinition

struct AttributeToDeclaration : Predicate<std::tuple<Fact<UserAttribute>, Declaration, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "hack.AttributeToDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct AttributeToDeclaration

struct AttributeHasParameter : Predicate<std::tuple<Fact<Name>, std::string, Fact<UserAttribute>>> {
  static const char* GLEAN_name() {
    return "hack.AttributeHasParameter";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct AttributeHasParameter

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::Argument> {
  using Type = Sum<facebook::glean::cpp::schema::Hack::StringLiteral, Repr<facebook::glean::cpp::schema::Hack::XRefTarget>>;
};


namespace schema {

namespace Hack {

struct Argument {
  boost::variant<Alt<0, Fact<StringLiteral>>, Alt<1, XRefTarget>> GLEAN_value;

  static Argument lit(const Fact<StringLiteral>& a) {
    return Argument{Alt<0, Fact<StringLiteral>>(a)};
  }
  static Argument xref(const XRefTarget& a) {
    return Argument{Alt<1, XRefTarget>(a)};
  }

  bool operator==(const Argument& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Argument& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Argument& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Argument& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Argument& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Argument& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Argument>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Argument

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Hack::CallArgument> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Src::RelByteSpan>, Maybe<Repr<facebook::glean::cpp::schema::Hack::Argument>>>;
};


namespace schema {

namespace Hack {

struct CallArgument {
  facebook::glean::cpp::schema::Src::RelByteSpan span;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Argument>> argument;

  bool operator==(const CallArgument& other) const {
    return std::tie(span,argument)
             == std::tie(other.span,other.argument);
  }
  bool operator!=(const CallArgument& other) const {
    return std::tie(span,argument)
             != std::tie(other.span,other.argument);
  }
  bool operator<(const CallArgument& other) const {
    return std::tie(span,argument)
             < std::tie(other.span,other.argument);
  }
  bool operator<=(const CallArgument& other) const {
    return std::tie(span,argument)
             <= std::tie(other.span,other.argument);
  }
  bool operator>(const CallArgument& other) const {
    return std::tie(span,argument)
             > std::tie(other.span,other.argument);
  }
  bool operator>=(const CallArgument& other) const {
    return std::tie(span,argument)
             >= std::tie(other.span,other.argument);
  }
  void outputRepr(Output<Repr<CallArgument>> out) const {
    outputValue(out, std::make_tuple(span, argument));
  }
}; // struct CallArgument

struct FileCall : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, std::vector<CallArgument>, boost::variant<Alt<0, std::tuple<>>, Alt<1, XRefTarget>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, CallArgument>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Declaration>>, std::set<XRefTarget>>> {
  static const char* GLEAN_name() {
    return "hack.FileCall";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct FileCall

} // namespace Hack

namespace Graphql {

struct VariableDef : Predicate<std::tuple<Fact<Value>, Fact<Value>, std::vector<Fact<Directive>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Value>>>>> {
  static const char* GLEAN_name() {
    return "graphql.VariableDef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct VariableDef

struct Value : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "graphql.Value";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Value

struct UnionTypeDef : Predicate<std::tuple<Fact<Value>, std::vector<Fact<Value>>, std::vector<Fact<Directive>>>> {
  static const char* GLEAN_name() {
    return "graphql.UnionTypeDef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct UnionTypeDef

} // namespace Graphql

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Graphql::SelectionSet> {
  using Type = Tuple<Array<facebook::glean::cpp::schema::Graphql::Field>, Array<facebook::glean::cpp::schema::Graphql::InlineFragment>, Array<facebook::glean::cpp::schema::Graphql::FragmentSpread>>;
};


namespace schema {

namespace Graphql {

struct SelectionSet {
  std::vector<Fact<Field>> fields;
  std::vector<Fact<InlineFragment>> inlineFragments;
  std::vector<Fact<FragmentSpread>> fragmentSpreads;

  bool operator==(const SelectionSet& other) const {
    return std::tie(fields,inlineFragments,fragmentSpreads)
             == std::tie(other.fields,other.inlineFragments,other.fragmentSpreads);
  }
  bool operator!=(const SelectionSet& other) const {
    return std::tie(fields,inlineFragments,fragmentSpreads)
             != std::tie(other.fields,other.inlineFragments,other.fragmentSpreads);
  }
  bool operator<(const SelectionSet& other) const {
    return std::tie(fields,inlineFragments,fragmentSpreads)
             < std::tie(other.fields,other.inlineFragments,other.fragmentSpreads);
  }
  bool operator<=(const SelectionSet& other) const {
    return std::tie(fields,inlineFragments,fragmentSpreads)
             <= std::tie(other.fields,other.inlineFragments,other.fragmentSpreads);
  }
  bool operator>(const SelectionSet& other) const {
    return std::tie(fields,inlineFragments,fragmentSpreads)
             > std::tie(other.fields,other.inlineFragments,other.fragmentSpreads);
  }
  bool operator>=(const SelectionSet& other) const {
    return std::tie(fields,inlineFragments,fragmentSpreads)
             >= std::tie(other.fields,other.inlineFragments,other.fragmentSpreads);
  }
  void outputRepr(Output<Repr<SelectionSet>> out) const {
    outputValue(out, std::make_tuple(fields, inlineFragments, fragmentSpreads));
  }
}; // struct SelectionSet

struct ScalarTypeDef : Predicate<std::tuple<Fact<Value>, std::vector<Fact<Directive>>>> {
  static const char* GLEAN_name() {
    return "graphql.ScalarTypeDef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ScalarTypeDef

} // namespace Graphql

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Graphql::OperationKind> {
  using Type = Enum<3>;
};


namespace schema {

namespace Graphql {

enum class OperationKind { QUERY, MUTATION, SUBSCRIPTION };

struct Operation : Predicate<std::tuple<Fact<Value>, OperationKind, std::vector<Fact<Directive>>, std::vector<Fact<VariableDef>>, SelectionSet, facebook::glean::cpp::schema::Src::FileLocation>> {
  static const char* GLEAN_name() {
    return "graphql.Operation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Operation

struct ObjectTypeDef : Predicate<std::tuple<Fact<Value>, std::vector<Fact<Value>>, std::vector<Fact<FieldDef>>, std::vector<Fact<Directive>>>> {
  static const char* GLEAN_name() {
    return "graphql.ObjectTypeDef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ObjectTypeDef

using Name = Fact<Value>;

struct NameLowerCase : Predicate<std::tuple<std::string, Name>> {
  static const char* GLEAN_name() {
    return "graphql.NameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct NameLowerCase

struct InterfaceTypeDef : Predicate<std::tuple<Fact<Value>, std::vector<Fact<FieldDef>>, std::vector<Fact<Directive>>>> {
  static const char* GLEAN_name() {
    return "graphql.InterfaceTypeDef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct InterfaceTypeDef

struct InputValueDef : Predicate<std::tuple<Fact<Value>, Fact<Value>, std::vector<Fact<Directive>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Value>>>>> {
  static const char* GLEAN_name() {
    return "graphql.InputValueDef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct InputValueDef

struct InputObjectTypeDef : Predicate<std::tuple<Fact<Value>, std::vector<Fact<InputValueDef>>, std::vector<Fact<Directive>>>> {
  static const char* GLEAN_name() {
    return "graphql.InputObjectTypeDef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct InputObjectTypeDef

struct InlineFragment : Predicate<std::tuple<Fact<Value>, std::vector<Fact<Directive>>, SelectionSet, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Value>>>>> {
  static const char* GLEAN_name() {
    return "graphql.InlineFragment";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct InlineFragment

struct FragmentSpread : Predicate<std::tuple<Fact<Value>, facebook::glean::cpp::schema::Src::FileLocation, std::vector<Fact<Argument>>, std::vector<Fact<Directive>>>> {
  static const char* GLEAN_name() {
    return "graphql.FragmentSpread";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FragmentSpread

struct Fragment : Predicate<std::tuple<Fact<Value>, Fact<Value>, std::vector<Fact<VariableDef>>, std::vector<Fact<Directive>>, SelectionSet, facebook::glean::cpp::schema::Src::FileLocation>> {
  static const char* GLEAN_name() {
    return "graphql.Fragment";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Fragment

struct FieldDef : Predicate<std::tuple<Fact<Value>, Fact<Value>, std::vector<Fact<InputValueDef>>, std::vector<Fact<Directive>>>> {
  static const char* GLEAN_name() {
    return "graphql.FieldDef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FieldDef

struct Field : Predicate<std::tuple<Fact<Value>, Fact<Value>, std::vector<Fact<Directive>>, SelectionSet, std::vector<Fact<Argument>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Value>>>, facebook::glean::cpp::schema::Src::FileLocation>> {
  static const char* GLEAN_name() {
    return "graphql.Field";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Field

struct EnumTypeDef : Predicate<std::tuple<Fact<Value>, std::vector<Fact<Value>>, std::vector<Fact<Directive>>>> {
  static const char* GLEAN_name() {
    return "graphql.EnumTypeDef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct EnumTypeDef

} // namespace Graphql

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Graphql::DirectiveDefLocation> {
  using Type = Enum<18>;
};


namespace schema {

namespace Graphql {

enum class DirectiveDefLocation { QUERY, MUTATION, SUBSCRIPTION, FIELD, FRAGMENT_DEFINITION, FRAGMENT_SPREAD, INLINE_FRAGMENT, SCHEMA, SCALAR, OBJECT, FIELD_DEFINITION, ARGUMENT_DEFINITION, INTERFACE, UNION, ENUM, ENUM_VALUE, INPUT_OBJECT, INPUT_FIELD_DEFINITION };

struct DirectiveDef : Predicate<std::tuple<Fact<Value>, std::vector<Fact<InputValueDef>>, std::vector<DirectiveDefLocation>>> {
  static const char* GLEAN_name() {
    return "graphql.DirectiveDef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DirectiveDef

struct Directive : Predicate<std::tuple<Fact<Value>, std::vector<Fact<Argument>>>> {
  static const char* GLEAN_name() {
    return "graphql.Directive";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Directive

} // namespace Graphql

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Graphql::Declaration> {
  using Type = Sum<facebook::glean::cpp::schema::Graphql::Operation, facebook::glean::cpp::schema::Graphql::Fragment, facebook::glean::cpp::schema::Graphql::FieldDef, facebook::glean::cpp::schema::Graphql::EnumTypeDef, facebook::glean::cpp::schema::Graphql::DirectiveDef>;
};


namespace schema {

namespace Graphql {

struct Declaration {
  boost::variant<Alt<0, Fact<Operation>>, Alt<1, Fact<Fragment>>, Alt<2, Fact<FieldDef>>, Alt<3, Fact<EnumTypeDef>>, Alt<4, Fact<DirectiveDef>>> GLEAN_value;

  static Declaration operation_(const Fact<Operation>& a) {
    return Declaration{Alt<0, Fact<Operation>>(a)};
  }
  static Declaration fragment_(const Fact<Fragment>& a) {
    return Declaration{Alt<1, Fact<Fragment>>(a)};
  }
  static Declaration field_(const Fact<FieldDef>& a) {
    return Declaration{Alt<2, Fact<FieldDef>>(a)};
  }
  static Declaration enum_(const Fact<EnumTypeDef>& a) {
    return Declaration{Alt<3, Fact<EnumTypeDef>>(a)};
  }
  static Declaration directive_(const Fact<DirectiveDef>& a) {
    return Declaration{Alt<4, Fact<DirectiveDef>>(a)};
  }

  bool operator==(const Declaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Declaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Declaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Declaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Declaration

struct DeclarationLocation : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "graphql.DeclarationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclarationLocation

struct DeclarationName : Predicate<Declaration, Fact<Value>> {
  static const char* GLEAN_name() {
    return "graphql.DeclarationName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclarationName

struct DeclarationUses : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "graphql.DeclarationUses";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclarationUses

struct FileDeclarations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, Declaration>> {
  static const char* GLEAN_name() {
    return "graphql.FileDeclarations";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FileDeclarations

struct SearchByName : Predicate<std::tuple<Name, Declaration>> {
  static const char* GLEAN_name() {
    return "graphql.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchByName

} // namespace Graphql

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Graphql::XRef> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Graphql::Declaration>, Repr<facebook::glean::cpp::schema::Src::ByteSpan>>;
};


namespace schema {

namespace Graphql {

struct XRef {
  Declaration decl;
  facebook::glean::cpp::schema::Src::ByteSpan span;

  bool operator==(const XRef& other) const {
    return std::tie(decl,span)
             == std::tie(other.decl,other.span);
  }
  bool operator!=(const XRef& other) const {
    return std::tie(decl,span)
             != std::tie(other.decl,other.span);
  }
  bool operator<(const XRef& other) const {
    return std::tie(decl,span)
             < std::tie(other.decl,other.span);
  }
  bool operator<=(const XRef& other) const {
    return std::tie(decl,span)
             <= std::tie(other.decl,other.span);
  }
  bool operator>(const XRef& other) const {
    return std::tie(decl,span)
             > std::tie(other.decl,other.span);
  }
  bool operator>=(const XRef& other) const {
    return std::tie(decl,span)
             >= std::tie(other.decl,other.span);
  }
  void outputRepr(Output<Repr<XRef>> out) const {
    outputValue(out, std::make_tuple(decl, span));
  }
}; // struct XRef

struct FileXRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, XRef>> {
  static const char* GLEAN_name() {
    return "graphql.FileXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FileXRefs

struct DeclHasName : Predicate<std::tuple<Declaration, Fact<Value>>> {
  static const char* GLEAN_name() {
    return "graphql.DeclHasName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclHasName

struct BelongToConfig : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Value>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Value>>>>> {
  static const char* GLEAN_name() {
    return "graphql.BelongToConfig";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct BelongToConfig

struct Argument : Predicate<std::tuple<Fact<Value>, Fact<Value>>> {
  static const char* GLEAN_name() {
    return "graphql.Argument";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Argument

} // namespace Graphql

namespace Glean {

namespace Test {

struct nothingTest : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, uint64_t>> {
  static const char* GLEAN_name() {
    return "glean.test.nothingTest";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct nothingTest

} // namespace Test

} // namespace Glean

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Glean::Test::WrappedStringPair> {
  using Type = Tuple<facebook::glean::cpp::schema::Glean::Test::StringPair>;
};


namespace schema {

namespace Glean {

namespace Test {

struct WrappedStringPair {
  Fact<StringPair> wrapped;

  bool operator==(const WrappedStringPair& other) const {
    return std::tie(wrapped)
             == std::tie(other.wrapped);
  }
  bool operator!=(const WrappedStringPair& other) const {
    return std::tie(wrapped)
             != std::tie(other.wrapped);
  }
  bool operator<(const WrappedStringPair& other) const {
    return std::tie(wrapped)
             < std::tie(other.wrapped);
  }
  bool operator<=(const WrappedStringPair& other) const {
    return std::tie(wrapped)
             <= std::tie(other.wrapped);
  }
  bool operator>(const WrappedStringPair& other) const {
    return std::tie(wrapped)
             > std::tie(other.wrapped);
  }
  bool operator>=(const WrappedStringPair& other) const {
    return std::tie(wrapped)
             >= std::tie(other.wrapped);
  }
  void outputRepr(Output<Repr<WrappedStringPair>> out) const {
    outputValue(out, std::make_tuple(wrapped));
  }
}; // struct WrappedStringPair

struct ViaStringPair : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.ViaStringPair";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ViaStringPair

struct Unbound2 : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.Unbound2";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Unbound2

struct Unbound : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.Unbound";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Unbound

struct TreeToTree : Predicate<Fact<Tree>, Fact<Tree>> {
  static const char* GLEAN_name() {
    return "glean.test.TreeToTree";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct TreeToTree

struct Tree : Predicate<std::tuple<Fact<Node>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Tree>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Tree>>>>> {
  static const char* GLEAN_name() {
    return "glean.test.Tree";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Tree

} // namespace Test

} // namespace Glean

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Glean::Test::Sum_> {
  using Type = Sum<Byte, Nat, Bool>;
};


namespace schema {

namespace Glean {

namespace Test {

struct Sum_ {
  boost::variant<Alt<0, uint8_t>, Alt<1, uint64_t>, Alt<2, bool>> GLEAN_value;

  static Sum_ mon(const uint8_t& a) {
    return Sum_{Alt<0, uint8_t>(a)};
  }
  static Sum_ tue(const uint64_t& a) {
    return Sum_{Alt<1, uint64_t>(a)};
  }
  static Sum_ wed(const bool& a) {
    return Sum_{Alt<2, bool>(a)};
  }

  bool operator==(const Sum_& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Sum_& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Sum_& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Sum_& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Sum_& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Sum_& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Sum_>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Sum_

struct StringPairBox : Predicate<std::tuple<Fact<StringPair>>> {
  static const char* GLEAN_name() {
    return "glean.test.StringPairBox";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct StringPairBox

struct StringPair : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.StringPair";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct StringPair

struct StoredRevStringPairWithRev : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.StoredRevStringPairWithRev";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct StoredRevStringPairWithRev

struct StoredRevStringPairWithA : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.StoredRevStringPairWithA";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct StoredRevStringPairWithA

struct StoredRevStringPairSum : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.StoredRevStringPairSum";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct StoredRevStringPairSum

struct StoredRevStringPair : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.StoredRevStringPair";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct StoredRevStringPair

struct StoredDualStringPair : Predicate<std::tuple<Fact<StringPair>, Fact<StringPair>>> {
  static const char* GLEAN_name() {
    return "glean.test.StoredDualStringPair";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct StoredDualStringPair

struct SkipRevEdge : Predicate<std::tuple<Fact<Node>, Fact<Node>>> {
  static const char* GLEAN_name() {
    return "glean.test.SkipRevEdge";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SkipRevEdge

struct SameString : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.SameString";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct SameString

struct RevStringPairs : Predicate<std::tuple<std::string, Fact<RevStringPair>>> {
  static const char* GLEAN_name() {
    return "glean.test.RevStringPairs";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct RevStringPairs

struct RevStringPairRec : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.RevStringPairRec";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct RevStringPairRec

struct RevStringPair : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.RevStringPair";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct RevStringPair

struct RevRevStringPair : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.RevRevStringPair";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct RevRevStringPair

struct RevEdge : Predicate<std::tuple<Fact<Node>, Fact<Node>>> {
  static const char* GLEAN_name() {
    return "glean.test.RevEdge";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct RevEdge

struct ReflStringPair : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "glean.test.ReflStringPair";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ReflStringPair

struct RefRef : Predicate<Fact<Ref>> {
  static const char* GLEAN_name() {
    return "glean.test.RefRef";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct RefRef

struct Ref : Predicate<Fact<Predicate_>> {
  static const char* GLEAN_name() {
    return "glean.test.Ref";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Ref

struct Qux : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "glean.test.Qux";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Qux

struct Predicate_0 : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "glean.test.Predicate";
  }

  static constexpr size_t GLEAN_version() {
     return 0;
  }
}; // struct Predicate_0

struct NodePair : Predicate<std::tuple<Fact<Node>, Fact<Node>>> {
  static const char* GLEAN_name() {
    return "glean.test.NodePair";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct NodePair

struct Node : Predicate<std::tuple<std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.Node";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Node

struct Name : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "glean.test.Name";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Name

struct MatchOneAlt : Predicate<std::tuple<Sum_, uint64_t>> {
  static const char* GLEAN_name() {
    return "glean.test.MatchOneAlt";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct MatchOneAlt

struct LeftOr2 : Predicate<std::tuple<std::string, uint64_t>> {
  static const char* GLEAN_name() {
    return "glean.test.LeftOr2";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct LeftOr2

struct LeftOr : Predicate<std::tuple<std::string, uint64_t>> {
  static const char* GLEAN_name() {
    return "glean.test.LeftOr";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct LeftOr

struct KeyValue : Predicate<std::tuple<std::string, uint64_t>, std::tuple<uint64_t, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.KeyValue";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct KeyValue

struct IsThree : Predicate<uint64_t> {
  static const char* GLEAN_name() {
    return "glean.test.IsThree";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct IsThree

struct IsParent : Predicate<Fact<Node>> {
  static const char* GLEAN_name() {
    return "glean.test.IsParent";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct IsParent

struct IsGlean : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "glean.test.IsGlean";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct IsGlean

struct FooToFoo : Predicate<Fact<Foo>, Fact<Foo>> {
  static const char* GLEAN_name() {
    return "glean.test.FooToFoo";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct FooToFoo

struct Foo : Predicate<std::string, Fact<Bar>> {
  static const char* GLEAN_name() {
    return "glean.test.Foo";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Foo

struct Expr : Predicate<boost::variant<Alt<0, Fact<Name>>, Alt<1, uint64_t>, Alt<2, Fact<Name>>, Alt<3, std::tuple<Fact<Expr>, Fact<Expr>>>, Alt<4, std::tuple<Fact<Name>, Fact<Expr>>>>> {
  static const char* GLEAN_name() {
    return "glean.test.Expr";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Expr

} // namespace Test

} // namespace Glean

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Glean::Test::Enum_> {
  using Type = Enum<3>;
};


namespace schema {

namespace Glean {

namespace Test {

enum class Enum_ { red, green, blue };

} // namespace Test

} // namespace Glean

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Glean::Test::Rec> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Glean::Test::Enum_>, Repr<facebook::glean::cpp::schema::Glean::Test::Sum_>>;
};


namespace schema {

namespace Glean {

namespace Test {

struct Rec {
  Enum_ alpha;
  Sum_ beta;

  bool operator==(const Rec& other) const {
    return std::tie(alpha,beta)
             == std::tie(other.alpha,other.beta);
  }
  bool operator!=(const Rec& other) const {
    return std::tie(alpha,beta)
             != std::tie(other.alpha,other.beta);
  }
  bool operator<(const Rec& other) const {
    return std::tie(alpha,beta)
             < std::tie(other.alpha,other.beta);
  }
  bool operator<=(const Rec& other) const {
    return std::tie(alpha,beta)
             <= std::tie(other.alpha,other.beta);
  }
  bool operator>(const Rec& other) const {
    return std::tie(alpha,beta)
             > std::tie(other.alpha,other.beta);
  }
  bool operator>=(const Rec& other) const {
    return std::tie(alpha,beta)
             >= std::tie(other.alpha,other.beta);
  }
  void outputRepr(Output<Repr<Rec>> out) const {
    outputValue(out, std::make_tuple(alpha, beta));
  }
}; // struct Rec

struct EmptyStoredStringPair : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.EmptyStoredStringPair";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct EmptyStoredStringPair

struct EmptyPred : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "glean.test.EmptyPred";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct EmptyPred

struct EdgeWrapper : Predicate<std::tuple<Fact<Edge>>> {
  static const char* GLEAN_name() {
    return "glean.test.EdgeWrapper";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct EdgeWrapper

} // namespace Test

} // namespace Glean

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Glean::Test::EdgeSum> {
  using Type = Sum<facebook::glean::cpp::schema::Glean::Test::EdgeWrapper, facebook::glean::cpp::schema::Glean::Test::EdgeWrapper>;
};


namespace schema {

namespace Glean {

namespace Test {

struct EdgeSum {
  boost::variant<Alt<0, Fact<EdgeWrapper>>, Alt<1, Fact<EdgeWrapper>>> GLEAN_value;

  static EdgeSum fst(const Fact<EdgeWrapper>& a) {
    return EdgeSum{Alt<0, Fact<EdgeWrapper>>(a)};
  }
  static EdgeSum snd(const Fact<EdgeWrapper>& a) {
    return EdgeSum{Alt<1, Fact<EdgeWrapper>>(a)};
  }

  bool operator==(const EdgeSum& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const EdgeSum& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const EdgeSum& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const EdgeSum& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const EdgeSum& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const EdgeSum& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<EdgeSum>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct EdgeSum

struct EdgeFromNotA : Predicate<Fact<Edge>> {
  static const char* GLEAN_name() {
    return "glean.test.EdgeFromNotA";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct EdgeFromNotA

struct Edge : Predicate<std::tuple<Fact<Node>, Fact<Node>>> {
  static const char* GLEAN_name() {
    return "glean.test.Edge";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Edge

struct DualStringPair : Predicate<std::tuple<Fact<StringPair>, Fact<StringPair>>> {
  static const char* GLEAN_name() {
    return "glean.test.DualStringPair";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct DualStringPair

struct DerivedKeyValue2 : Predicate<std::tuple<std::string, uint64_t>, std::tuple<uint64_t, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.DerivedKeyValue2";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct DerivedKeyValue2

struct DerivedKeyValue : Predicate<std::tuple<std::string, uint64_t, uint64_t, std::string>> {
  static const char* GLEAN_name() {
    return "glean.test.DerivedKeyValue";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct DerivedKeyValue

struct Bar : Predicate<std::string, Fact<Qux>> {
  static const char* GLEAN_name() {
    return "glean.test.Bar";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Bar

using ArrayString = std::vector<std::string>;

using ArrayNat = std::vector<uint64_t>;

using ArrayByte = std::vector<uint8_t>;

using ArrayBool = std::vector<bool>;

enum class KitchenSink_enum_ { e, f, g };

} // namespace Test

} // namespace Glean

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Glean::Test::KitchenSink_enum_> {
  using Type = Enum<3>;
};


template<> struct Repr_<facebook::glean::cpp::schema::Glean::Test::KitchenSink> {
  using Type = Tuple<Byte, Nat, Bool, String, facebook::glean::cpp::schema::Sys::Blob, Maybe<Tuple<>>, Tuple<Byte, Nat>, Sum<facebook::glean::cpp::schema::Glean::Test::Predicate_, facebook::glean::cpp::schema::Sys::Blob>, Enum<3>, Repr<facebook::glean::cpp::schema::Glean::Test::Rec>, Repr<facebook::glean::cpp::schema::Glean::Test::Sum_>, Repr<facebook::glean::cpp::schema::Glean::Test::Enum_>, Array<Byte>, Array<Nat>, Array<Bool>, Array<String>, Array<facebook::glean::cpp::schema::Glean::Test::Predicate_>, Array<Repr<facebook::glean::cpp::schema::Glean::Test::Rec>>, Array<Repr<facebook::glean::cpp::schema::Glean::Test::Sum_>>, Array<Repr<facebook::glean::cpp::schema::Glean::Test::Enum_>>, Array<Repr<facebook::glean::cpp::schema::Glean::Test::ArrayByte>>, Array<Repr<facebook::glean::cpp::schema::Glean::Test::ArrayNat>>, Array<Repr<facebook::glean::cpp::schema::Glean::Test::ArrayBool>>, Array<Repr<facebook::glean::cpp::schema::Glean::Test::ArrayString>>, Set<Nat>, Set<String>, Set<facebook::glean::cpp::schema::Glean::Test::Predicate_>>;
};


namespace schema {

namespace Glean {

namespace Test {

struct KitchenSink {
  uint8_t byt;
  uint64_t nat;
  bool bool_;
  std::string string_;
  Fact<facebook::glean::cpp::schema::Sys::Blob> pred;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, std::tuple<>>> maybe_;
  std::tuple<uint8_t, uint64_t> record_;
  boost::variant<Alt<0, Fact<Predicate_>>, Alt<1, Fact<facebook::glean::cpp::schema::Sys::Blob>>> sum_;
  KitchenSink_enum_ enum_;
  Rec named_record_;
  Sum_ named_sum_;
  Enum_ named_enum_;
  std::vector<uint8_t> array_of_byte;
  std::vector<uint64_t> array_of_nat;
  std::vector<bool> array_of_bool;
  std::vector<std::string> array_of_string;
  std::vector<Fact<Predicate_>> array_of_pred;
  std::vector<Rec> array_of_named_record;
  std::vector<Sum_> array_of_named_sum;
  std::vector<Enum_> array_of_named_enum;
  std::vector<ArrayByte> array2_of_byte;
  std::vector<ArrayNat> array2_of_nat;
  std::vector<ArrayBool> array2_of_bool;
  std::vector<ArrayString> array2_of_string;
  std::set<uint64_t> set_of_nat;
  std::set<std::string> set_of_string;
  std::set<Fact<Predicate_>> set_of_pred;

  bool operator==(const KitchenSink& other) const {
    return std::tie(byt,nat,bool_,string_,pred,maybe_,record_,sum_,enum_,named_record_,named_sum_,named_enum_,array_of_byte,array_of_nat,array_of_bool,array_of_string,array_of_pred,array_of_named_record,array_of_named_sum,array_of_named_enum,array2_of_byte,array2_of_nat,array2_of_bool,array2_of_string,set_of_nat,set_of_string,set_of_pred)
             == std::tie(other.byt,other.nat,other.bool_,other.string_,other.pred,other.maybe_,other.record_,other.sum_,other.enum_,other.named_record_,other.named_sum_,other.named_enum_,other.array_of_byte,other.array_of_nat,other.array_of_bool,other.array_of_string,other.array_of_pred,other.array_of_named_record,other.array_of_named_sum,other.array_of_named_enum,other.array2_of_byte,other.array2_of_nat,other.array2_of_bool,other.array2_of_string,other.set_of_nat,other.set_of_string,other.set_of_pred);
  }
  bool operator!=(const KitchenSink& other) const {
    return std::tie(byt,nat,bool_,string_,pred,maybe_,record_,sum_,enum_,named_record_,named_sum_,named_enum_,array_of_byte,array_of_nat,array_of_bool,array_of_string,array_of_pred,array_of_named_record,array_of_named_sum,array_of_named_enum,array2_of_byte,array2_of_nat,array2_of_bool,array2_of_string,set_of_nat,set_of_string,set_of_pred)
             != std::tie(other.byt,other.nat,other.bool_,other.string_,other.pred,other.maybe_,other.record_,other.sum_,other.enum_,other.named_record_,other.named_sum_,other.named_enum_,other.array_of_byte,other.array_of_nat,other.array_of_bool,other.array_of_string,other.array_of_pred,other.array_of_named_record,other.array_of_named_sum,other.array_of_named_enum,other.array2_of_byte,other.array2_of_nat,other.array2_of_bool,other.array2_of_string,other.set_of_nat,other.set_of_string,other.set_of_pred);
  }
  bool operator<(const KitchenSink& other) const {
    return std::tie(byt,nat,bool_,string_,pred,maybe_,record_,sum_,enum_,named_record_,named_sum_,named_enum_,array_of_byte,array_of_nat,array_of_bool,array_of_string,array_of_pred,array_of_named_record,array_of_named_sum,array_of_named_enum,array2_of_byte,array2_of_nat,array2_of_bool,array2_of_string,set_of_nat,set_of_string,set_of_pred)
             < std::tie(other.byt,other.nat,other.bool_,other.string_,other.pred,other.maybe_,other.record_,other.sum_,other.enum_,other.named_record_,other.named_sum_,other.named_enum_,other.array_of_byte,other.array_of_nat,other.array_of_bool,other.array_of_string,other.array_of_pred,other.array_of_named_record,other.array_of_named_sum,other.array_of_named_enum,other.array2_of_byte,other.array2_of_nat,other.array2_of_bool,other.array2_of_string,other.set_of_nat,other.set_of_string,other.set_of_pred);
  }
  bool operator<=(const KitchenSink& other) const {
    return std::tie(byt,nat,bool_,string_,pred,maybe_,record_,sum_,enum_,named_record_,named_sum_,named_enum_,array_of_byte,array_of_nat,array_of_bool,array_of_string,array_of_pred,array_of_named_record,array_of_named_sum,array_of_named_enum,array2_of_byte,array2_of_nat,array2_of_bool,array2_of_string,set_of_nat,set_of_string,set_of_pred)
             <= std::tie(other.byt,other.nat,other.bool_,other.string_,other.pred,other.maybe_,other.record_,other.sum_,other.enum_,other.named_record_,other.named_sum_,other.named_enum_,other.array_of_byte,other.array_of_nat,other.array_of_bool,other.array_of_string,other.array_of_pred,other.array_of_named_record,other.array_of_named_sum,other.array_of_named_enum,other.array2_of_byte,other.array2_of_nat,other.array2_of_bool,other.array2_of_string,other.set_of_nat,other.set_of_string,other.set_of_pred);
  }
  bool operator>(const KitchenSink& other) const {
    return std::tie(byt,nat,bool_,string_,pred,maybe_,record_,sum_,enum_,named_record_,named_sum_,named_enum_,array_of_byte,array_of_nat,array_of_bool,array_of_string,array_of_pred,array_of_named_record,array_of_named_sum,array_of_named_enum,array2_of_byte,array2_of_nat,array2_of_bool,array2_of_string,set_of_nat,set_of_string,set_of_pred)
             > std::tie(other.byt,other.nat,other.bool_,other.string_,other.pred,other.maybe_,other.record_,other.sum_,other.enum_,other.named_record_,other.named_sum_,other.named_enum_,other.array_of_byte,other.array_of_nat,other.array_of_bool,other.array_of_string,other.array_of_pred,other.array_of_named_record,other.array_of_named_sum,other.array_of_named_enum,other.array2_of_byte,other.array2_of_nat,other.array2_of_bool,other.array2_of_string,other.set_of_nat,other.set_of_string,other.set_of_pred);
  }
  bool operator>=(const KitchenSink& other) const {
    return std::tie(byt,nat,bool_,string_,pred,maybe_,record_,sum_,enum_,named_record_,named_sum_,named_enum_,array_of_byte,array_of_nat,array_of_bool,array_of_string,array_of_pred,array_of_named_record,array_of_named_sum,array_of_named_enum,array2_of_byte,array2_of_nat,array2_of_bool,array2_of_string,set_of_nat,set_of_string,set_of_pred)
             >= std::tie(other.byt,other.nat,other.bool_,other.string_,other.pred,other.maybe_,other.record_,other.sum_,other.enum_,other.named_record_,other.named_sum_,other.named_enum_,other.array_of_byte,other.array_of_nat,other.array_of_bool,other.array_of_string,other.array_of_pred,other.array_of_named_record,other.array_of_named_sum,other.array_of_named_enum,other.array2_of_byte,other.array2_of_nat,other.array2_of_bool,other.array2_of_string,other.set_of_nat,other.set_of_string,other.set_of_pred);
  }
  void outputRepr(Output<Repr<KitchenSink>> out) const {
    outputValue(out, std::make_tuple(byt, nat, bool_, string_, pred, maybe_, record_, sum_, enum_, named_record_, named_sum_, named_enum_, array_of_byte, array_of_nat, array_of_bool, array_of_string, array_of_pred, array_of_named_record, array_of_named_sum, array_of_named_enum, array2_of_byte, array2_of_nat, array2_of_bool, array2_of_string, set_of_nat, set_of_string, set_of_pred));
  }
}; // struct KitchenSink

struct Predicate_ : Predicate<KitchenSink> {
  static const char* GLEAN_name() {
    return "glean.test.Predicate";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Predicate_

} // namespace Test

} // namespace Glean

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Gencode::GenCodeVariant> {
  using Type = Enum<2>;
};


namespace schema {

namespace Gencode {

enum class GenCodeVariant { Full, Partial };

struct GenCodeSignature : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "gencode.GenCodeSignature";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct GenCodeSignature

struct GenCodeCommand : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "gencode.GenCodeCommand";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct GenCodeCommand

struct GenCodeClass : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "gencode.GenCodeClass";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct GenCodeClass

struct GenCodeBySource : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "gencode.GenCodeBySource";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct GenCodeBySource

struct GenCode : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, GenCodeVariant, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Src::File>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<GenCodeCommand>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<GenCodeClass>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<GenCodeSignature>>>>> {
  static const char* GLEAN_name() {
    return "gencode.GenCode";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct GenCode

} // namespace Gencode

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Flow::XRef> {
  using Type = Sum<facebook::glean::cpp::schema::Flow::LocalDeclarationReference, facebook::glean::cpp::schema::Flow::MemberDeclarationReference, facebook::glean::cpp::schema::Flow::TypeDeclarationReference>;
};


namespace schema {

namespace Flow {

struct XRef {
  boost::variant<Alt<0, Fact<LocalDeclarationReference>>, Alt<1, Fact<MemberDeclarationReference>>, Alt<2, Fact<TypeDeclarationReference>>> GLEAN_value;

  static XRef localRef(const Fact<LocalDeclarationReference>& a) {
    return XRef{Alt<0, Fact<LocalDeclarationReference>>(a)};
  }
  static XRef memberRef(const Fact<MemberDeclarationReference>& a) {
    return XRef{Alt<1, Fact<MemberDeclarationReference>>(a)};
  }
  static XRef typeRef(const Fact<TypeDeclarationReference>& a) {
    return XRef{Alt<2, Fact<TypeDeclarationReference>>(a)};
  }

  bool operator==(const XRef& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const XRef& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const XRef& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const XRef& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const XRef& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const XRef& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<XRef>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct XRef

struct TypeImportDeclaration : Predicate<std::tuple<Fact<TypeDeclaration>, boost::variant<Alt<0, Fact<ModuleTypeExport>>, Alt<1, Fact<ModuleExport>>, Alt<2, Fact<Module>>>>> {
  static const char* GLEAN_name() {
    return "flow.TypeImportDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct TypeImportDeclaration

struct TypeExport : Predicate<boost::variant<Alt<0, Fact<Name>>, Alt<1, Fact<Module>>>> {
  static const char* GLEAN_name() {
    return "flow.TypeExport";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct TypeExport

struct TypeDeclarationReference : Predicate<std::tuple<Fact<TypeDeclaration>, Fact<Range>>> {
  static const char* GLEAN_name() {
    return "flow.TypeDeclarationReference";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct TypeDeclarationReference

struct TypeDeclarationInfo : Predicate<std::tuple<Fact<TypeDeclaration>, Fact<Type>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Documentation>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Range>>>>> {
  static const char* GLEAN_name() {
    return "flow.TypeDeclarationInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct TypeDeclarationInfo

struct TypeDeclaration : Predicate<std::tuple<Fact<Name>, Fact<Range>>> {
  static const char* GLEAN_name() {
    return "flow.TypeDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct TypeDeclaration

struct Type : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "flow.Type";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Type

struct StringToFileModule : Predicate<std::tuple<std::string, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "flow.StringToFileModule";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct StringToFileModule

struct SourceOfTypeExport : Predicate<std::tuple<Fact<ModuleTypeExport>, boost::variant<Alt<0, Fact<TypeDeclaration>>, Alt<1, Fact<ModuleTypeExport>>, Alt<2, Fact<Module>>>>> {
  static const char* GLEAN_name() {
    return "flow.SourceOfTypeExport";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SourceOfTypeExport

struct SourceOfExport : Predicate<std::tuple<Fact<ModuleExport>, boost::variant<Alt<0, Fact<Declaration>>, Alt<1, Fact<MemberDeclaration>>, Alt<2, Fact<ModuleExport>>, Alt<3, Fact<Module>>>>> {
  static const char* GLEAN_name() {
    return "flow.SourceOfExport";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SourceOfExport

} // namespace Flow

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Flow::SomeDeclaration> {
  using Type = Sum<facebook::glean::cpp::schema::Flow::Declaration, facebook::glean::cpp::schema::Flow::MemberDeclaration, facebook::glean::cpp::schema::Flow::TypeDeclaration>;
};


namespace schema {

namespace Flow {

struct SomeDeclaration {
  boost::variant<Alt<0, Fact<Declaration>>, Alt<1, Fact<MemberDeclaration>>, Alt<2, Fact<TypeDeclaration>>> GLEAN_value;

  static SomeDeclaration localDecl(const Fact<Declaration>& a) {
    return SomeDeclaration{Alt<0, Fact<Declaration>>(a)};
  }
  static SomeDeclaration memberDecl(const Fact<MemberDeclaration>& a) {
    return SomeDeclaration{Alt<1, Fact<MemberDeclaration>>(a)};
  }
  static SomeDeclaration typeDecl(const Fact<TypeDeclaration>& a) {
    return SomeDeclaration{Alt<2, Fact<TypeDeclaration>>(a)};
  }

  bool operator==(const SomeDeclaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const SomeDeclaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const SomeDeclaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const SomeDeclaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const SomeDeclaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const SomeDeclaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<SomeDeclaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct SomeDeclaration

} // namespace Flow

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Flow::SomeEntity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Flow::SomeDeclaration>, facebook::glean::cpp::schema::Flow::Module>;
};


namespace schema {

namespace Flow {

struct SomeEntity {
  boost::variant<Alt<0, SomeDeclaration>, Alt<1, Fact<Module>>> GLEAN_value;

  static SomeEntity decl(const SomeDeclaration& a) {
    return SomeEntity{Alt<0, SomeDeclaration>(a)};
  }
  static SomeEntity module_(const Fact<Module>& a) {
    return SomeEntity{Alt<1, Fact<Module>>(a)};
  }

  bool operator==(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const SomeEntity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<SomeEntity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct SomeEntity

} // namespace Flow

namespace Search {

namespace Flow {

struct FlowSearchByNameNonImport : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Flow::Name>, facebook::glean::cpp::schema::Flow::SomeDeclaration>> {
  static const char* GLEAN_name() {
    return "search.flow.FlowSearchByNameNonImport";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FlowSearchByNameNonImport

} // namespace Flow

} // namespace Search

namespace Flow {

struct SearchTypeDeclarationByName : Predicate<std::tuple<std::string, Fact<Module>, Fact<TypeDeclaration>>> {
  static const char* GLEAN_name() {
    return "flow.SearchTypeDeclarationByName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchTypeDeclarationByName

struct SearchTypeDeclarationByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "flow.SearchTypeDeclarationByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchTypeDeclarationByLowerCaseName

struct SearchTypeByModuleExport : Predicate<std::tuple<std::string, Fact<Name>, SomeDeclaration>> {
  static const char* GLEAN_name() {
    return "flow.SearchTypeByModuleExport";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchTypeByModuleExport

struct SearchModuleByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "flow.SearchModuleByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchModuleByLowerCaseName

struct SearchMemberDeclarationByName : Predicate<std::tuple<std::string, Fact<Module>, Fact<MemberDeclaration>>> {
  static const char* GLEAN_name() {
    return "flow.SearchMemberDeclarationByName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchMemberDeclarationByName

struct SearchMemberDeclarationByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "flow.SearchMemberDeclarationByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchMemberDeclarationByLowerCaseName

struct SearchDeclarationByName : Predicate<std::tuple<std::string, Fact<Module>, Fact<Declaration>>> {
  static const char* GLEAN_name() {
    return "flow.SearchDeclarationByName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchDeclarationByName

struct SearchDeclarationByLowerCaseName : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "flow.SearchDeclarationByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchDeclarationByLowerCaseName

struct SearchByNameModule : Predicate<std::tuple<std::string, Fact<Module>>> {
  static const char* GLEAN_name() {
    return "flow.SearchByNameModule";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchByNameModule

struct SearchByName : Predicate<std::tuple<Fact<Name>, SomeDeclaration>> {
  static const char* GLEAN_name() {
    return "flow.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchByName

struct SearchByModuleName : Predicate<std::tuple<std::string, Fact<Module>>> {
  static const char* GLEAN_name() {
    return "flow.SearchByModuleName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchByModuleName

struct SearchByModule : Predicate<std::tuple<std::string, Fact<Name>, SomeDeclaration>> {
  static const char* GLEAN_name() {
    return "flow.SearchByModule";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchByModule

struct SearchByFileModule : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Name>, SomeDeclaration>> {
  static const char* GLEAN_name() {
    return "flow.SearchByFileModule";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct SearchByFileModule

struct Range : Predicate<std::tuple<Fact<Module>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "flow.Range";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Range

struct Name : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "flow.Name";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Name

struct ModuleTypeExport : Predicate<std::tuple<Fact<Module>, Fact<TypeExport>>> {
  static const char* GLEAN_name() {
    return "flow.ModuleTypeExport";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ModuleTypeExport

struct ModuleNameLowerCase : Predicate<std::tuple<std::string, Fact<Module>>> {
  static const char* GLEAN_name() {
    return "flow.ModuleNameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ModuleNameLowerCase

struct ModuleLocationByFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Module>, facebook::glean::cpp::schema::Src::ByteSpan, std::string>> {
  static const char* GLEAN_name() {
    return "flow.ModuleLocationByFile";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ModuleLocationByFile

struct ModuleLocation : Predicate<std::tuple<Fact<Module>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, std::string>> {
  static const char* GLEAN_name() {
    return "flow.ModuleLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ModuleLocation

struct ModuleExport : Predicate<std::tuple<Fact<Module>, Fact<Export>>> {
  static const char* GLEAN_name() {
    return "flow.ModuleExport";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ModuleExport

struct ModuleDoc : Predicate<std::tuple<Fact<Documentation>, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "flow.ModuleDoc";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ModuleDoc

struct ModuleContains : Predicate<std::tuple<Fact<Module>, SomeDeclaration>> {
  static const char* GLEAN_name() {
    return "flow.ModuleContains";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ModuleContains

struct ModuleComments : Predicate<std::tuple<Fact<Module>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "flow.ModuleComments";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ModuleComments

struct Module : Predicate<boost::variant<Alt<0, Fact<facebook::glean::cpp::schema::Src::File>>, Alt<1, std::tuple<>>, Alt<2, std::string>, Alt<3, std::tuple<>>, Alt<4, std::string>>> {
  static const char* GLEAN_name() {
    return "flow.Module";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Module

struct MemberDeclarationReference : Predicate<std::tuple<Fact<MemberDeclaration>, Fact<Range>>> {
  static const char* GLEAN_name() {
    return "flow.MemberDeclarationReference";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct MemberDeclarationReference

struct MemberDeclarationInfo : Predicate<std::tuple<Fact<MemberDeclaration>, Fact<Type>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Documentation>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Range>>>>> {
  static const char* GLEAN_name() {
    return "flow.MemberDeclarationInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct MemberDeclarationInfo

struct MemberDeclaration : Predicate<std::tuple<Fact<Name>, Fact<Range>>> {
  static const char* GLEAN_name() {
    return "flow.MemberDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct MemberDeclaration

struct LocalDeclarationReference : Predicate<std::tuple<Fact<Declaration>, Fact<Range>>> {
  static const char* GLEAN_name() {
    return "flow.LocalDeclarationReference";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct LocalDeclarationReference

struct ImportDeclaration : Predicate<std::tuple<Fact<Declaration>, boost::variant<Alt<0, Fact<ModuleExport>>, Alt<1, Fact<Module>>>>> {
  static const char* GLEAN_name() {
    return "flow.ImportDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct ImportDeclaration

struct FlowXRefDeclInfo : Predicate<std::tuple<XRef, Fact<Range>, Fact<Name>, Fact<Range>, SomeDeclaration>> {
  static const char* GLEAN_name() {
    return "flow.FlowXRefDeclInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FlowXRefDeclInfo

struct FlowTypeImportXRef : Predicate<std::tuple<Fact<TypeDeclaration>, SomeEntity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "flow.FlowTypeImportXRef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FlowTypeImportXRef

struct FlowTypeExportLocation : Predicate<std::tuple<Fact<ModuleTypeExport>, SomeEntity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "flow.FlowTypeExportLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FlowTypeExportLocation

struct FlowTypeEntityImportUses : Predicate<std::tuple<SomeEntity, Fact<TypeDeclaration>>> {
  static const char* GLEAN_name() {
    return "flow.FlowTypeEntityImportUses";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FlowTypeEntityImportUses

struct FlowSameModule : Predicate<std::tuple<Fact<Module>, Fact<Module>>> {
  static const char* GLEAN_name() {
    return "flow.FlowSameModule";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FlowSameModule

struct FlowModuleNamespaceXRef : Predicate<std::tuple<Fact<Declaration>, SomeEntity, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "flow.FlowModuleNamespaceXRef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FlowModuleNamespaceXRef

struct FlowImportXRef : Predicate<std::tuple<Fact<Declaration>, SomeEntity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "flow.FlowImportXRef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FlowImportXRef

struct FlowExportLocation : Predicate<std::tuple<Fact<Module>, Fact<Export>, SomeEntity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "flow.FlowExportLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FlowExportLocation

struct FlowEntityUsesAll : Predicate<std::tuple<SomeEntity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "flow.FlowEntityUsesAll";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FlowEntityUsesAll

struct FlowEntityImportUses : Predicate<std::tuple<SomeEntity, Fact<Declaration>>> {
  static const char* GLEAN_name() {
    return "flow.FlowEntityImportUses";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FlowEntityImportUses

struct FlowCompatibleExport : Predicate<std::tuple<Fact<Export>, Fact<Export>>> {
  static const char* GLEAN_name() {
    return "flow.FlowCompatibleExport";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FlowCompatibleExport

struct FileXRef : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, XRef>> {
  static const char* GLEAN_name() {
    return "flow.FileXRef";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FileXRef

struct FileOfStringModule : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::string>> {
  static const char* GLEAN_name() {
    return "flow.FileOfStringModule";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FileOfStringModule

struct FileDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, SomeDeclaration>> {
  static const char* GLEAN_name() {
    return "flow.FileDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct FileDeclaration

struct Export : Predicate<boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Name>>, Alt<2, Fact<Name>>, Alt<3, std::tuple<>>, Alt<4, Fact<Module>>>> {
  static const char* GLEAN_name() {
    return "flow.Export";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Export

struct Documentation : Predicate<Fact<Range>> {
  static const char* GLEAN_name() {
    return "flow.Documentation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Documentation

struct DeclarationUses : Predicate<std::tuple<SomeDeclaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "flow.DeclarationUses";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclarationUses

struct DeclarationSignature : Predicate<std::tuple<SomeDeclaration, std::string>> {
  static const char* GLEAN_name() {
    return "flow.DeclarationSignature";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclarationSignature

struct DeclarationNameSpan : Predicate<std::tuple<SomeDeclaration, Fact<Name>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "flow.DeclarationNameSpan";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclarationNameSpan

struct DeclarationLocation : Predicate<std::tuple<SomeDeclaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "flow.DeclarationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclarationLocation

struct DeclarationInfo : Predicate<std::tuple<Fact<Declaration>, Fact<Type>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Documentation>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Range>>>>> {
  static const char* GLEAN_name() {
    return "flow.DeclarationInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct DeclarationInfo

struct Declaration : Predicate<std::tuple<Fact<Name>, Fact<Range>>> {
  static const char* GLEAN_name() {
    return "flow.Declaration";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct Declaration

} // namespace Flow

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::XRefTarget> {
  using Type = Sum<facebook::glean::cpp::schema::Fbthrift::File, facebook::glean::cpp::schema::Fbthrift::NamedDecl, facebook::glean::cpp::schema::Fbthrift::ExceptionName, facebook::glean::cpp::schema::Fbthrift::ServiceName, facebook::glean::cpp::schema::Fbthrift::Constant, facebook::glean::cpp::schema::Fbthrift::EnumValue, facebook::glean::cpp::schema::Fbthrift::FunctionName, facebook::glean::cpp::schema::Fbthrift::FieldDecl>;
};


namespace schema {

namespace Fbthrift {

struct XRefTarget {
  boost::variant<Alt<0, Fact<File>>, Alt<1, Fact<NamedDecl>>, Alt<2, Fact<ExceptionName>>, Alt<3, Fact<ServiceName>>, Alt<4, Fact<Constant>>, Alt<5, Fact<EnumValue>>, Alt<6, Fact<FunctionName>>, Alt<7, Fact<FieldDecl>>> GLEAN_value;

  static XRefTarget include_(const Fact<File>& a) {
    return XRefTarget{Alt<0, Fact<File>>(a)};
  }
  static XRefTarget named(const Fact<NamedDecl>& a) {
    return XRefTarget{Alt<1, Fact<NamedDecl>>(a)};
  }
  static XRefTarget exception_(const Fact<ExceptionName>& a) {
    return XRefTarget{Alt<2, Fact<ExceptionName>>(a)};
  }
  static XRefTarget service_(const Fact<ServiceName>& a) {
    return XRefTarget{Alt<3, Fact<ServiceName>>(a)};
  }
  static XRefTarget constant(const Fact<Constant>& a) {
    return XRefTarget{Alt<4, Fact<Constant>>(a)};
  }
  static XRefTarget enumValue(const Fact<EnumValue>& a) {
    return XRefTarget{Alt<5, Fact<EnumValue>>(a)};
  }
  static XRefTarget function_(const Fact<FunctionName>& a) {
    return XRefTarget{Alt<6, Fact<FunctionName>>(a)};
  }
  static XRefTarget field(const Fact<FieldDecl>& a) {
    return XRefTarget{Alt<7, Fact<FieldDecl>>(a)};
  }

  bool operator==(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<XRefTarget>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct XRefTarget

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::TypedConst> {
  using Type = Sum<facebook::glean::cpp::schema::Fbthrift::Literal, facebook::glean::cpp::schema::Fbthrift::Constant>;
};


namespace schema {

namespace Fbthrift {

struct TypedConst {
  boost::variant<Alt<0, Fact<Literal>>, Alt<1, Fact<Constant>>> GLEAN_value;

  static TypedConst literal(const Fact<Literal>& a) {
    return TypedConst{Alt<0, Fact<Literal>>(a)};
  }
  static TypedConst identifier(const Fact<Constant>& a) {
    return TypedConst{Alt<1, Fact<Constant>>(a)};
  }

  bool operator==(const TypedConst& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const TypedConst& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const TypedConst& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const TypedConst& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const TypedConst& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const TypedConst& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<TypedConst>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct TypedConst

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::TypedConstT> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Fbthrift::TypedConst>, facebook::glean::cpp::schema::Fbthrift::TypeSpecification>;
};


namespace schema {

namespace Fbthrift {

struct TypedConstT {
  TypedConst const_;
  Fact<TypeSpecification> type_;

  bool operator==(const TypedConstT& other) const {
    return std::tie(const_,type_)
             == std::tie(other.const_,other.type_);
  }
  bool operator!=(const TypedConstT& other) const {
    return std::tie(const_,type_)
             != std::tie(other.const_,other.type_);
  }
  bool operator<(const TypedConstT& other) const {
    return std::tie(const_,type_)
             < std::tie(other.const_,other.type_);
  }
  bool operator<=(const TypedConstT& other) const {
    return std::tie(const_,type_)
             <= std::tie(other.const_,other.type_);
  }
  bool operator>(const TypedConstT& other) const {
    return std::tie(const_,type_)
             > std::tie(other.const_,other.type_);
  }
  bool operator>=(const TypedConstT& other) const {
    return std::tie(const_,type_)
             >= std::tie(other.const_,other.type_);
  }
  void outputRepr(Output<Repr<TypedConstT>> out) const {
    outputValue(out, std::make_tuple(const_, type_));
  }
}; // struct TypedConstT

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::UnionFieldVal> {
  using Type = Tuple<facebook::glean::cpp::schema::Fbthrift::Identifier, Repr<facebook::glean::cpp::schema::Fbthrift::TypedConstT>>;
};


namespace schema {

namespace Fbthrift {

struct UnionFieldVal {
  Fact<Identifier> name;
  TypedConstT value;

  bool operator==(const UnionFieldVal& other) const {
    return std::tie(name,value)
             == std::tie(other.name,other.value);
  }
  bool operator!=(const UnionFieldVal& other) const {
    return std::tie(name,value)
             != std::tie(other.name,other.value);
  }
  bool operator<(const UnionFieldVal& other) const {
    return std::tie(name,value)
             < std::tie(other.name,other.value);
  }
  bool operator<=(const UnionFieldVal& other) const {
    return std::tie(name,value)
             <= std::tie(other.name,other.value);
  }
  bool operator>(const UnionFieldVal& other) const {
    return std::tie(name,value)
             > std::tie(other.name,other.value);
  }
  bool operator>=(const UnionFieldVal& other) const {
    return std::tie(name,value)
             >= std::tie(other.name,other.value);
  }
  void outputRepr(Output<Repr<UnionFieldVal>> out) const {
    outputValue(out, std::make_tuple(name, value));
  }
}; // struct UnionFieldVal

struct UnionVal : Predicate<std::tuple<UnionFieldVal>> {
  static const char* GLEAN_name() {
    return "fbthrift.UnionVal";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct UnionVal

struct TypeDefType : Predicate<std::tuple<Fact<QualName>, Fact<TypeSpecification>, std::vector<Fact<StructuredAnnotation>>>> {
  static const char* GLEAN_name() {
    return "fbthrift.TypeDefType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TypeDefType

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::Target> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Fbthrift::XRefTarget>>;
};


namespace schema {

namespace Fbthrift {

struct Target {
  XRefTarget target;

  bool operator==(const Target& other) const {
    return std::tie(target)
             == std::tie(other.target);
  }
  bool operator!=(const Target& other) const {
    return std::tie(target)
             != std::tie(other.target);
  }
  bool operator<(const Target& other) const {
    return std::tie(target)
             < std::tie(other.target);
  }
  bool operator<=(const Target& other) const {
    return std::tie(target)
             <= std::tie(other.target);
  }
  bool operator>(const Target& other) const {
    return std::tie(target)
             > std::tie(other.target);
  }
  bool operator>=(const Target& other) const {
    return std::tie(target)
             >= std::tie(other.target);
  }
  void outputRepr(Output<Repr<Target>> out) const {
    outputValue(out, std::make_tuple(target));
  }
}; // struct Target

struct StructuredAnnotation : Predicate<std::tuple<Fact<TypeSpecification>, Fact<StructVal>>> {
  static const char* GLEAN_name() {
    return "fbthrift.StructuredAnnotation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct StructuredAnnotation

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::StructFieldValValue> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Fbthrift::TypedConstT>, facebook::glean::cpp::schema::Fbthrift::TypeSpecification, Repr<facebook::glean::cpp::schema::Fbthrift::TypedConstT>, Tuple<>>;
};


namespace schema {

namespace Fbthrift {

struct StructFieldValValue {
  boost::variant<Alt<0, TypedConstT>, Alt<1, Fact<TypeSpecification>>, Alt<2, TypedConstT>, Alt<3, std::tuple<>>> GLEAN_value;

  static StructFieldValValue val(const TypedConstT& a) {
    return StructFieldValValue{Alt<0, TypedConstT>(a)};
  }
  static StructFieldValValue default_(const Fact<TypeSpecification>& a) {
    return StructFieldValValue{Alt<1, Fact<TypeSpecification>>(a)};
  }
  static StructFieldValValue just(const TypedConstT& a) {
    return StructFieldValValue{Alt<2, TypedConstT>(a)};
  }
  static StructFieldValValue nothing() {
    return StructFieldValValue{Alt<3, std::tuple<>>(std::make_tuple())};
  }

  bool operator==(const StructFieldValValue& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const StructFieldValValue& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const StructFieldValValue& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const StructFieldValValue& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const StructFieldValValue& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const StructFieldValValue& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<StructFieldValValue>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct StructFieldValValue

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::StructFieldVal> {
  using Type = Tuple<facebook::glean::cpp::schema::Fbthrift::Identifier, Repr<facebook::glean::cpp::schema::Fbthrift::StructFieldValValue>>;
};


namespace schema {

namespace Fbthrift {

struct StructFieldVal {
  Fact<Identifier> name;
  StructFieldValValue value;

  bool operator==(const StructFieldVal& other) const {
    return std::tie(name,value)
             == std::tie(other.name,other.value);
  }
  bool operator!=(const StructFieldVal& other) const {
    return std::tie(name,value)
             != std::tie(other.name,other.value);
  }
  bool operator<(const StructFieldVal& other) const {
    return std::tie(name,value)
             < std::tie(other.name,other.value);
  }
  bool operator<=(const StructFieldVal& other) const {
    return std::tie(name,value)
             <= std::tie(other.name,other.value);
  }
  bool operator>(const StructFieldVal& other) const {
    return std::tie(name,value)
             > std::tie(other.name,other.value);
  }
  bool operator>=(const StructFieldVal& other) const {
    return std::tie(name,value)
             >= std::tie(other.name,other.value);
  }
  void outputRepr(Output<Repr<StructFieldVal>> out) const {
    outputValue(out, std::make_tuple(name, value));
  }
}; // struct StructFieldVal

struct StructVal : Predicate<std::tuple<std::vector<StructFieldVal>>> {
  static const char* GLEAN_name() {
    return "fbthrift.StructVal";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct StructVal

struct ServiceParent : Predicate<std::tuple<Fact<ServiceName>, Fact<ServiceName>>> {
  static const char* GLEAN_name() {
    return "fbthrift.ServiceParent";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ServiceParent

struct ServiceName : Predicate<std::tuple<Fact<QualName>>> {
  static const char* GLEAN_name() {
    return "fbthrift.ServiceName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ServiceName

struct ServiceInteractionFunctions : Predicate<std::tuple<Fact<ServiceName>, Fact<FunctionSpecification>>> {
  static const char* GLEAN_name() {
    return "fbthrift.ServiceInteractionFunctions";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ServiceInteractionFunctions

struct ServiceDefinition : Predicate<std::tuple<Fact<ServiceName>, std::vector<Fact<FunctionSpecification>>, std::vector<Fact<StructuredAnnotation>>, std::vector<Fact<InteractionName>>>> {
  static const char* GLEAN_name() {
    return "fbthrift.ServiceDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ServiceDefinition

struct ServiceChild : Predicate<std::tuple<Fact<ServiceName>, Fact<ServiceName>>> {
  static const char* GLEAN_name() {
    return "fbthrift.ServiceChild";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ServiceChild

struct SearchByName : Predicate<std::tuple<Fact<Identifier>, Fact<QualName>>> {
  static const char* GLEAN_name() {
    return "fbthrift.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchByName

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::ResultSink> {
  using Type = Tuple<facebook::glean::cpp::schema::Fbthrift::TypeSpecification, Maybe<facebook::glean::cpp::schema::Fbthrift::TypeSpecification>, Maybe<facebook::glean::cpp::schema::Fbthrift::TypeSpecification>>;
};


namespace schema {

namespace Fbthrift {

struct ResultSink {
  Fact<TypeSpecification> type_;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeSpecification>>> firstResponse;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeSpecification>>> finalResponse;

  bool operator==(const ResultSink& other) const {
    return std::tie(type_,firstResponse,finalResponse)
             == std::tie(other.type_,other.firstResponse,other.finalResponse);
  }
  bool operator!=(const ResultSink& other) const {
    return std::tie(type_,firstResponse,finalResponse)
             != std::tie(other.type_,other.firstResponse,other.finalResponse);
  }
  bool operator<(const ResultSink& other) const {
    return std::tie(type_,firstResponse,finalResponse)
             < std::tie(other.type_,other.firstResponse,other.finalResponse);
  }
  bool operator<=(const ResultSink& other) const {
    return std::tie(type_,firstResponse,finalResponse)
             <= std::tie(other.type_,other.firstResponse,other.finalResponse);
  }
  bool operator>(const ResultSink& other) const {
    return std::tie(type_,firstResponse,finalResponse)
             > std::tie(other.type_,other.firstResponse,other.finalResponse);
  }
  bool operator>=(const ResultSink& other) const {
    return std::tie(type_,firstResponse,finalResponse)
             >= std::tie(other.type_,other.firstResponse,other.finalResponse);
  }
  void outputRepr(Output<Repr<ResultSink>> out) const {
    outputValue(out, std::make_tuple(type_, firstResponse, finalResponse));
  }
}; // struct ResultSink

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::Qualifier> {
  using Type = Enum<3>;
};


namespace schema {

namespace Fbthrift {

enum class Qualifier { default_, optional_, required_ };

struct QualName : Predicate<std::tuple<Fact<File>, Fact<Identifier>>> {
  static const char* GLEAN_name() {
    return "fbthrift.QualName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct QualName

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::PrimitiveType> {
  using Type = Enum<9>;
};


namespace schema {

namespace Fbthrift {

enum class PrimitiveType { bool_, byte_, i16_, i32_, i64_, float_, double_, binary_, string_ };

struct PackageName : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "fbthrift.PackageName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct PackageName

struct Package : Predicate<std::tuple<Fact<File>, Fact<PackageName>>> {
  static const char* GLEAN_name() {
    return "fbthrift.Package";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Package

struct NamespaceValue : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "fbthrift.NamespaceValue";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct NamespaceValue

struct NamespaceName : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "fbthrift.NamespaceName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct NamespaceName

struct Namespace : Predicate<std::tuple<Fact<File>, Fact<NamespaceName>, Fact<NamespaceValue>, bool>> {
  static const char* GLEAN_name() {
    return "fbthrift.Namespace";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Namespace

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::NamedKind> {
  using Type = Enum<4>;
};


namespace schema {

namespace Fbthrift {

enum class NamedKind { typedef_, enum_, struct_, union_ };

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::NamedType> {
  using Type = Tuple<facebook::glean::cpp::schema::Fbthrift::QualName, Repr<facebook::glean::cpp::schema::Fbthrift::NamedKind>>;
};


namespace schema {

namespace Fbthrift {

struct NamedType {
  Fact<QualName> name;
  NamedKind kind;

  bool operator==(const NamedType& other) const {
    return std::tie(name,kind)
             == std::tie(other.name,other.kind);
  }
  bool operator!=(const NamedType& other) const {
    return std::tie(name,kind)
             != std::tie(other.name,other.kind);
  }
  bool operator<(const NamedType& other) const {
    return std::tie(name,kind)
             < std::tie(other.name,other.kind);
  }
  bool operator<=(const NamedType& other) const {
    return std::tie(name,kind)
             <= std::tie(other.name,other.kind);
  }
  bool operator>(const NamedType& other) const {
    return std::tie(name,kind)
             > std::tie(other.name,other.kind);
  }
  bool operator>=(const NamedType& other) const {
    return std::tie(name,kind)
             >= std::tie(other.name,other.kind);
  }
  void outputRepr(Output<Repr<NamedType>> out) const {
    outputValue(out, std::make_tuple(name, kind));
  }
}; // struct NamedType

struct NamedDecl : Predicate<std::tuple<NamedType>> {
  static const char* GLEAN_name() {
    return "fbthrift.NamedDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct NamedDecl

struct NameLowerCase : Predicate<std::tuple<std::string, Fact<Identifier>>> {
  static const char* GLEAN_name() {
    return "fbthrift.NameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct NameLowerCase

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::MapType> {
  using Type = Tuple<facebook::glean::cpp::schema::Fbthrift::TypeSpecification, facebook::glean::cpp::schema::Fbthrift::TypeSpecification>;
};


namespace schema {

namespace Fbthrift {

struct MapType {
  Fact<TypeSpecification> key_;
  Fact<TypeSpecification> value;

  bool operator==(const MapType& other) const {
    return std::tie(key_,value)
             == std::tie(other.key_,other.value);
  }
  bool operator!=(const MapType& other) const {
    return std::tie(key_,value)
             != std::tie(other.key_,other.value);
  }
  bool operator<(const MapType& other) const {
    return std::tie(key_,value)
             < std::tie(other.key_,other.value);
  }
  bool operator<=(const MapType& other) const {
    return std::tie(key_,value)
             <= std::tie(other.key_,other.value);
  }
  bool operator>(const MapType& other) const {
    return std::tie(key_,value)
             > std::tie(other.key_,other.value);
  }
  bool operator>=(const MapType& other) const {
    return std::tie(key_,value)
             >= std::tie(other.key_,other.value);
  }
  void outputRepr(Output<Repr<MapType>> out) const {
    outputValue(out, std::make_tuple(key_, value));
  }
}; // struct MapType

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::Loc> {
  using Type = Tuple<Nat, Nat, Nat, Nat>;
};


namespace schema {

namespace Fbthrift {

struct Loc {
  uint64_t startLine;
  uint64_t startCol;
  uint64_t endLine;
  uint64_t endCol;

  bool operator==(const Loc& other) const {
    return std::tie(startLine,startCol,endLine,endCol)
             == std::tie(other.startLine,other.startCol,other.endLine,other.endCol);
  }
  bool operator!=(const Loc& other) const {
    return std::tie(startLine,startCol,endLine,endCol)
             != std::tie(other.startLine,other.startCol,other.endLine,other.endCol);
  }
  bool operator<(const Loc& other) const {
    return std::tie(startLine,startCol,endLine,endCol)
             < std::tie(other.startLine,other.startCol,other.endLine,other.endCol);
  }
  bool operator<=(const Loc& other) const {
    return std::tie(startLine,startCol,endLine,endCol)
             <= std::tie(other.startLine,other.startCol,other.endLine,other.endCol);
  }
  bool operator>(const Loc& other) const {
    return std::tie(startLine,startCol,endLine,endCol)
             > std::tie(other.startLine,other.startCol,other.endLine,other.endCol);
  }
  bool operator>=(const Loc& other) const {
    return std::tie(startLine,startCol,endLine,endCol)
             >= std::tie(other.startLine,other.startCol,other.endLine,other.endCol);
  }
  void outputRepr(Output<Repr<Loc>> out) const {
    outputValue(out, std::make_tuple(startLine, startCol, endLine, endCol));
  }
}; // struct Loc

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::XRef> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Fbthrift::Loc>, Repr<facebook::glean::cpp::schema::Fbthrift::XRefTarget>>;
};


namespace schema {

namespace Fbthrift {

struct XRef {
  Loc locRef;
  XRefTarget target;

  bool operator==(const XRef& other) const {
    return std::tie(locRef,target)
             == std::tie(other.locRef,other.target);
  }
  bool operator!=(const XRef& other) const {
    return std::tie(locRef,target)
             != std::tie(other.locRef,other.target);
  }
  bool operator<(const XRef& other) const {
    return std::tie(locRef,target)
             < std::tie(other.locRef,other.target);
  }
  bool operator<=(const XRef& other) const {
    return std::tie(locRef,target)
             <= std::tie(other.locRef,other.target);
  }
  bool operator>(const XRef& other) const {
    return std::tie(locRef,target)
             > std::tie(other.locRef,other.target);
  }
  bool operator>=(const XRef& other) const {
    return std::tie(locRef,target)
             >= std::tie(other.locRef,other.target);
  }
  void outputRepr(Output<Repr<XRef>> out) const {
    outputValue(out, std::make_tuple(locRef, target));
  }
}; // struct XRef

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::KeyValue> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Fbthrift::TypedConst>, Repr<facebook::glean::cpp::schema::Fbthrift::TypedConst>>;
};


namespace schema {

namespace Fbthrift {

struct KeyValue {
  TypedConst key;
  TypedConst value;

  bool operator==(const KeyValue& other) const {
    return std::tie(key,value)
             == std::tie(other.key,other.value);
  }
  bool operator!=(const KeyValue& other) const {
    return std::tie(key,value)
             != std::tie(other.key,other.value);
  }
  bool operator<(const KeyValue& other) const {
    return std::tie(key,value)
             < std::tie(other.key,other.value);
  }
  bool operator<=(const KeyValue& other) const {
    return std::tie(key,value)
             <= std::tie(other.key,other.value);
  }
  bool operator>(const KeyValue& other) const {
    return std::tie(key,value)
             > std::tie(other.key,other.value);
  }
  bool operator>=(const KeyValue& other) const {
    return std::tie(key,value)
             >= std::tie(other.key,other.value);
  }
  void outputRepr(Output<Repr<KeyValue>> out) const {
    outputValue(out, std::make_tuple(key, value));
  }
}; // struct KeyValue

struct InteractionName : Predicate<std::tuple<Fact<QualName>>> {
  static const char* GLEAN_name() {
    return "fbthrift.InteractionName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct InteractionName

struct InteractionDefinition : Predicate<std::tuple<Fact<InteractionName>, std::vector<Fact<FunctionSpecification>>, std::vector<Fact<StructuredAnnotation>>>> {
  static const char* GLEAN_name() {
    return "fbthrift.InteractionDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct InteractionDefinition

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::IntegerLiteral> {
  using Type = Tuple<Bool, Nat>;
};


namespace schema {

namespace Fbthrift {

struct IntegerLiteral {
  bool isNonNegative;
  uint64_t absValue;

  bool operator==(const IntegerLiteral& other) const {
    return std::tie(isNonNegative,absValue)
             == std::tie(other.isNonNegative,other.absValue);
  }
  bool operator!=(const IntegerLiteral& other) const {
    return std::tie(isNonNegative,absValue)
             != std::tie(other.isNonNegative,other.absValue);
  }
  bool operator<(const IntegerLiteral& other) const {
    return std::tie(isNonNegative,absValue)
             < std::tie(other.isNonNegative,other.absValue);
  }
  bool operator<=(const IntegerLiteral& other) const {
    return std::tie(isNonNegative,absValue)
             <= std::tie(other.isNonNegative,other.absValue);
  }
  bool operator>(const IntegerLiteral& other) const {
    return std::tie(isNonNegative,absValue)
             > std::tie(other.isNonNegative,other.absValue);
  }
  bool operator>=(const IntegerLiteral& other) const {
    return std::tie(isNonNegative,absValue)
             >= std::tie(other.isNonNegative,other.absValue);
  }
  void outputRepr(Output<Repr<IntegerLiteral>> out) const {
    outputValue(out, std::make_tuple(isNonNegative, absValue));
  }
}; // struct IntegerLiteral

struct Identifier : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "fbthrift.Identifier";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Identifier

struct FunctionName : Predicate<std::tuple<Fact<ServiceName>, Fact<Identifier>>> {
  static const char* GLEAN_name() {
    return "fbthrift.FunctionName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FunctionName

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::FloatLiteral> {
  using Type = Tuple<Bool, Bool, Nat, Nat>;
};


namespace schema {

namespace Fbthrift {

struct FloatLiteral {
  bool isNaN;
  bool isPositive;
  uint64_t exponent;
  uint64_t significand;

  bool operator==(const FloatLiteral& other) const {
    return std::tie(isNaN,isPositive,exponent,significand)
             == std::tie(other.isNaN,other.isPositive,other.exponent,other.significand);
  }
  bool operator!=(const FloatLiteral& other) const {
    return std::tie(isNaN,isPositive,exponent,significand)
             != std::tie(other.isNaN,other.isPositive,other.exponent,other.significand);
  }
  bool operator<(const FloatLiteral& other) const {
    return std::tie(isNaN,isPositive,exponent,significand)
             < std::tie(other.isNaN,other.isPositive,other.exponent,other.significand);
  }
  bool operator<=(const FloatLiteral& other) const {
    return std::tie(isNaN,isPositive,exponent,significand)
             <= std::tie(other.isNaN,other.isPositive,other.exponent,other.significand);
  }
  bool operator>(const FloatLiteral& other) const {
    return std::tie(isNaN,isPositive,exponent,significand)
             > std::tie(other.isNaN,other.isPositive,other.exponent,other.significand);
  }
  bool operator>=(const FloatLiteral& other) const {
    return std::tie(isNaN,isPositive,exponent,significand)
             >= std::tie(other.isNaN,other.isPositive,other.exponent,other.significand);
  }
  void outputRepr(Output<Repr<FloatLiteral>> out) const {
    outputValue(out, std::make_tuple(isNaN, isPositive, exponent, significand));
  }
}; // struct FloatLiteral

struct Literal : Predicate<boost::variant<Alt<0, IntegerLiteral>, Alt<1, IntegerLiteral>, Alt<2, IntegerLiteral>, Alt<3, IntegerLiteral>, Alt<4, FloatLiteral>, Alt<5, FloatLiteral>, Alt<6, bool>, Alt<7, std::string>, Alt<8, std::vector<uint8_t>>, Alt<9, std::vector<TypedConst>>, Alt<10, std::vector<TypedConst>>, Alt<11, std::vector<KeyValue>>, Alt<12, Fact<Literal>>, Alt<13, Fact<StructVal>>, Alt<14, Fact<ExceptionVal>>, Alt<15, Fact<UnionVal>>, Alt<16, Fact<EnumVal>>>> {
  static const char* GLEAN_name() {
    return "fbthrift.Literal";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Literal

struct FileXRefs : Predicate<std::tuple<Fact<File>, std::vector<XRef>>> {
  static const char* GLEAN_name() {
    return "fbthrift.FileXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileXRefs

struct File : Predicate<Fact<facebook::glean::cpp::schema::Src::File>> {
  static const char* GLEAN_name() {
    return "fbthrift.File";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct File

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::FieldKind> {
  using Type = Enum<3>;
};


namespace schema {

namespace Fbthrift {

enum class FieldKind { struct_, union_, exception_ };

using FieldId = IntegerLiteral;

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::FieldSpecification> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Fbthrift::FieldId>, Repr<facebook::glean::cpp::schema::Fbthrift::Qualifier>, facebook::glean::cpp::schema::Fbthrift::TypeSpecification, facebook::glean::cpp::schema::Fbthrift::Identifier, Maybe<Repr<facebook::glean::cpp::schema::Fbthrift::TypedConst>>, Array<facebook::glean::cpp::schema::Fbthrift::StructuredAnnotation>>;
};


namespace schema {

namespace Fbthrift {

struct FieldSpecification {
  FieldId id;
  Qualifier qualifier;
  Fact<TypeSpecification> type_;
  Fact<Identifier> name;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, TypedConst>> value;
  std::vector<Fact<StructuredAnnotation>> structuredAnnotations;

  bool operator==(const FieldSpecification& other) const {
    return std::tie(id,qualifier,type_,name,value,structuredAnnotations)
             == std::tie(other.id,other.qualifier,other.type_,other.name,other.value,other.structuredAnnotations);
  }
  bool operator!=(const FieldSpecification& other) const {
    return std::tie(id,qualifier,type_,name,value,structuredAnnotations)
             != std::tie(other.id,other.qualifier,other.type_,other.name,other.value,other.structuredAnnotations);
  }
  bool operator<(const FieldSpecification& other) const {
    return std::tie(id,qualifier,type_,name,value,structuredAnnotations)
             < std::tie(other.id,other.qualifier,other.type_,other.name,other.value,other.structuredAnnotations);
  }
  bool operator<=(const FieldSpecification& other) const {
    return std::tie(id,qualifier,type_,name,value,structuredAnnotations)
             <= std::tie(other.id,other.qualifier,other.type_,other.name,other.value,other.structuredAnnotations);
  }
  bool operator>(const FieldSpecification& other) const {
    return std::tie(id,qualifier,type_,name,value,structuredAnnotations)
             > std::tie(other.id,other.qualifier,other.type_,other.name,other.value,other.structuredAnnotations);
  }
  bool operator>=(const FieldSpecification& other) const {
    return std::tie(id,qualifier,type_,name,value,structuredAnnotations)
             >= std::tie(other.id,other.qualifier,other.type_,other.name,other.value,other.structuredAnnotations);
  }
  void outputRepr(Output<Repr<FieldSpecification>> out) const {
    outputValue(out, std::make_tuple(id, qualifier, type_, name, value, structuredAnnotations));
  }
}; // struct FieldSpecification

struct StructType : Predicate<std::tuple<Fact<QualName>, std::vector<FieldSpecification>, std::vector<Fact<StructuredAnnotation>>>> {
  static const char* GLEAN_name() {
    return "fbthrift.StructType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct StructType

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::UnqualField> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Fbthrift::FieldId>, facebook::glean::cpp::schema::Fbthrift::TypeSpecification, facebook::glean::cpp::schema::Fbthrift::Identifier, Array<facebook::glean::cpp::schema::Fbthrift::StructuredAnnotation>>;
};


namespace schema {

namespace Fbthrift {

struct UnqualField {
  FieldId id;
  Fact<TypeSpecification> type_;
  Fact<Identifier> name;
  std::vector<Fact<StructuredAnnotation>> structuredAnnotations;

  bool operator==(const UnqualField& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             == std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  bool operator!=(const UnqualField& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             != std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  bool operator<(const UnqualField& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             < std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  bool operator<=(const UnqualField& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             <= std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  bool operator>(const UnqualField& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             > std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  bool operator>=(const UnqualField& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             >= std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  void outputRepr(Output<Repr<UnqualField>> out) const {
    outputValue(out, std::make_tuple(id, type_, name, structuredAnnotations));
  }
}; // struct UnqualField

struct UnionType : Predicate<std::tuple<Fact<QualName>, std::vector<UnqualField>, std::vector<Fact<StructuredAnnotation>>>> {
  static const char* GLEAN_name() {
    return "fbthrift.UnionType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct UnionType

struct FieldDecl : Predicate<std::tuple<Fact<QualName>, FieldKind, Fact<Identifier>>> {
  static const char* GLEAN_name() {
    return "fbthrift.FieldDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FieldDecl

struct ExceptionVal : Predicate<Fact<StructVal>> {
  static const char* GLEAN_name() {
    return "fbthrift.ExceptionVal";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ExceptionVal

struct ExceptionType : Predicate<std::tuple<Fact<QualName>, std::vector<FieldSpecification>, std::vector<Fact<StructuredAnnotation>>>> {
  static const char* GLEAN_name() {
    return "fbthrift.ExceptionType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ExceptionType

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::ExceptionSpecName> {
  using Type = Sum<facebook::glean::cpp::schema::Fbthrift::ExceptionName, facebook::glean::cpp::schema::Fbthrift::TypeDefException>;
};


namespace schema {

namespace Fbthrift {

struct ExceptionSpecName {
  boost::variant<Alt<0, Fact<ExceptionName>>, Alt<1, Fact<TypeDefException>>> GLEAN_value;

  static ExceptionSpecName simple(const Fact<ExceptionName>& a) {
    return ExceptionSpecName{Alt<0, Fact<ExceptionName>>(a)};
  }
  static ExceptionSpecName typedef_(const Fact<TypeDefException>& a) {
    return ExceptionSpecName{Alt<1, Fact<TypeDefException>>(a)};
  }

  bool operator==(const ExceptionSpecName& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const ExceptionSpecName& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const ExceptionSpecName& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const ExceptionSpecName& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const ExceptionSpecName& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const ExceptionSpecName& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<ExceptionSpecName>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct ExceptionSpecName

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::ExceptionSpecification> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Fbthrift::FieldId>, Repr<facebook::glean::cpp::schema::Fbthrift::ExceptionSpecName>, facebook::glean::cpp::schema::Fbthrift::Identifier, Array<facebook::glean::cpp::schema::Fbthrift::StructuredAnnotation>>;
};


namespace schema {

namespace Fbthrift {

struct ExceptionSpecification {
  FieldId id;
  ExceptionSpecName type_;
  Fact<Identifier> name;
  std::vector<Fact<StructuredAnnotation>> structuredAnnotations;

  bool operator==(const ExceptionSpecification& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             == std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  bool operator!=(const ExceptionSpecification& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             != std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  bool operator<(const ExceptionSpecification& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             < std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  bool operator<=(const ExceptionSpecification& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             <= std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  bool operator>(const ExceptionSpecification& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             > std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  bool operator>=(const ExceptionSpecification& other) const {
    return std::tie(id,type_,name,structuredAnnotations)
             >= std::tie(other.id,other.type_,other.name,other.structuredAnnotations);
  }
  void outputRepr(Output<Repr<ExceptionSpecification>> out) const {
    outputValue(out, std::make_tuple(id, type_, name, structuredAnnotations));
  }
}; // struct ExceptionSpecification

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::ResultStream> {
  using Type = Tuple<Maybe<facebook::glean::cpp::schema::Fbthrift::TypeSpecification>, facebook::glean::cpp::schema::Fbthrift::TypeSpecification, Array<Repr<facebook::glean::cpp::schema::Fbthrift::ExceptionSpecification>>>;
};


namespace schema {

namespace Fbthrift {

struct ResultStream {
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<TypeSpecification>>> response;
  Fact<TypeSpecification> stream_;
  std::vector<ExceptionSpecification> throws_;

  bool operator==(const ResultStream& other) const {
    return std::tie(response,stream_,throws_)
             == std::tie(other.response,other.stream_,other.throws_);
  }
  bool operator!=(const ResultStream& other) const {
    return std::tie(response,stream_,throws_)
             != std::tie(other.response,other.stream_,other.throws_);
  }
  bool operator<(const ResultStream& other) const {
    return std::tie(response,stream_,throws_)
             < std::tie(other.response,other.stream_,other.throws_);
  }
  bool operator<=(const ResultStream& other) const {
    return std::tie(response,stream_,throws_)
             <= std::tie(other.response,other.stream_,other.throws_);
  }
  bool operator>(const ResultStream& other) const {
    return std::tie(response,stream_,throws_)
             > std::tie(other.response,other.stream_,other.throws_);
  }
  bool operator>=(const ResultStream& other) const {
    return std::tie(response,stream_,throws_)
             >= std::tie(other.response,other.stream_,other.throws_);
  }
  void outputRepr(Output<Repr<ResultStream>> out) const {
    outputValue(out, std::make_tuple(response, stream_, throws_));
  }
}; // struct ResultStream

struct TypeDefException : Predicate<std::tuple<Fact<NamedDecl>, ExceptionSpecName>> {
  static const char* GLEAN_name() {
    return "fbthrift.TypeDefException";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TypeDefException

struct ExceptionName : Predicate<std::tuple<Fact<QualName>>> {
  static const char* GLEAN_name() {
    return "fbthrift.ExceptionName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ExceptionName

struct EnumerationType : Predicate<std::tuple<Fact<QualName>, std::vector<Fact<EnumValueDef>>, std::vector<Fact<StructuredAnnotation>>>> {
  static const char* GLEAN_name() {
    return "fbthrift.EnumerationType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EnumerationType

struct EnumValueDef : Predicate<std::tuple<Fact<EnumValue>, IntegerLiteral, std::vector<Fact<StructuredAnnotation>>>> {
  static const char* GLEAN_name() {
    return "fbthrift.EnumValueDef";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EnumValueDef

struct EnumValue : Predicate<std::tuple<NamedType, Fact<Identifier>>> {
  static const char* GLEAN_name() {
    return "fbthrift.EnumValue";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EnumValue

struct EnumVal : Predicate<std::tuple<Fact<QualName>>> {
  static const char* GLEAN_name() {
    return "fbthrift.EnumVal";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EnumVal

using Declaration = XRefTarget;

struct DeclarationComment : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "fbthrift.DeclarationComment";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationComment

struct DeclarationFile : Predicate<std::tuple<Declaration, Fact<File>>> {
  static const char* GLEAN_name() {
    return "fbthrift.DeclarationFile";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationFile

struct DeclarationMember : Predicate<std::tuple<Fact<QualName>, Fact<Identifier>, Declaration>> {
  static const char* GLEAN_name() {
    return "fbthrift.DeclarationMember";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationMember

struct DeclarationName : Predicate<std::tuple<Fact<QualName>, Declaration>> {
  static const char* GLEAN_name() {
    return "fbthrift.DeclarationName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationName

struct DeclarationNameSpan : Predicate<std::tuple<Declaration, Fact<Identifier>, Fact<File>, Loc>> {
  static const char* GLEAN_name() {
    return "fbthrift.DeclarationNameSpan";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationNameSpan

struct DeclarationUses : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, Loc>> {
  static const char* GLEAN_name() {
    return "fbthrift.DeclarationUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationUses

struct FileDeclaration : Predicate<std::tuple<Fact<File>, Declaration>> {
  static const char* GLEAN_name() {
    return "fbthrift.FileDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileDeclaration

struct FunctionDeclarationName : Predicate<std::tuple<Fact<QualName>, Fact<Identifier>, Declaration>> {
  static const char* GLEAN_name() {
    return "fbthrift.FunctionDeclarationName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FunctionDeclarationName

} // namespace Fbthrift

namespace Hack {

struct HackToThrift : Predicate<std::tuple<Declaration, facebook::glean::cpp::schema::Fbthrift::Declaration>> {
  static const char* GLEAN_name() {
    return "hack.HackToThrift";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct HackToThrift

struct ThriftToHack : Predicate<std::tuple<facebook::glean::cpp::schema::Fbthrift::Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "hack.ThriftToHack";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ThriftToHack

} // namespace Hack

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::ContainerType> {
  using Type = Sum<facebook::glean::cpp::schema::Fbthrift::TypeSpecification, facebook::glean::cpp::schema::Fbthrift::TypeSpecification, Repr<facebook::glean::cpp::schema::Fbthrift::MapType>>;
};


namespace schema {

namespace Fbthrift {

struct ContainerType {
  boost::variant<Alt<0, Fact<TypeSpecification>>, Alt<1, Fact<TypeSpecification>>, Alt<2, MapType>> GLEAN_value;

  static ContainerType list_(const Fact<TypeSpecification>& a) {
    return ContainerType{Alt<0, Fact<TypeSpecification>>(a)};
  }
  static ContainerType set_(const Fact<TypeSpecification>& a) {
    return ContainerType{Alt<1, Fact<TypeSpecification>>(a)};
  }
  static ContainerType map_(const MapType& a) {
    return ContainerType{Alt<2, MapType>(a)};
  }

  bool operator==(const ContainerType& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const ContainerType& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const ContainerType& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const ContainerType& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const ContainerType& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const ContainerType& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<ContainerType>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct ContainerType

struct TypeSpecification : Predicate<boost::variant<Alt<0, PrimitiveType>, Alt<1, ContainerType>, Alt<2, NamedType>>> {
  static const char* GLEAN_name() {
    return "fbthrift.TypeSpecification";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TypeSpecification

struct ConstantDefinition : Predicate<std::tuple<Fact<Constant>, TypedConstT>> {
  static const char* GLEAN_name() {
    return "fbthrift.ConstantDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ConstantDefinition

struct Constant : Predicate<std::tuple<Fact<QualName>>> {
  static const char* GLEAN_name() {
    return "fbthrift.Constant";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Constant

} // namespace Fbthrift

namespace Erlang {

struct NameLowerCase : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "erlang.NameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct NameLowerCase

} // namespace Erlang

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Erlang::Fqn> {
  using Type = Tuple<String, String, Nat>;
};


namespace schema {

namespace Erlang {

struct Fqn {
  std::string module;
  std::string name;
  uint64_t arity;

  bool operator==(const Fqn& other) const {
    return std::tie(module,name,arity)
             == std::tie(other.module,other.name,other.arity);
  }
  bool operator!=(const Fqn& other) const {
    return std::tie(module,name,arity)
             != std::tie(other.module,other.name,other.arity);
  }
  bool operator<(const Fqn& other) const {
    return std::tie(module,name,arity)
             < std::tie(other.module,other.name,other.arity);
  }
  bool operator<=(const Fqn& other) const {
    return std::tie(module,name,arity)
             <= std::tie(other.module,other.name,other.arity);
  }
  bool operator>(const Fqn& other) const {
    return std::tie(module,name,arity)
             > std::tie(other.module,other.name,other.arity);
  }
  bool operator>=(const Fqn& other) const {
    return std::tie(module,name,arity)
             >= std::tie(other.module,other.name,other.arity);
  }
  void outputRepr(Output<Repr<Fqn>> out) const {
    outputValue(out, std::make_tuple(module, name, arity));
  }
}; // struct Fqn

struct FunctionDeclaration : Predicate<std::tuple<Fqn, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "erlang.FunctionDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FunctionDeclaration

} // namespace Erlang

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Erlang::XRefViaFqn> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Erlang::Fqn>, Repr<facebook::glean::cpp::schema::Src::ByteSpan>>;
};


namespace schema {

namespace Erlang {

struct XRefViaFqn {
  Fqn target;
  facebook::glean::cpp::schema::Src::ByteSpan source;

  bool operator==(const XRefViaFqn& other) const {
    return std::tie(target,source)
             == std::tie(other.target,other.source);
  }
  bool operator!=(const XRefViaFqn& other) const {
    return std::tie(target,source)
             != std::tie(other.target,other.source);
  }
  bool operator<(const XRefViaFqn& other) const {
    return std::tie(target,source)
             < std::tie(other.target,other.source);
  }
  bool operator<=(const XRefViaFqn& other) const {
    return std::tie(target,source)
             <= std::tie(other.target,other.source);
  }
  bool operator>(const XRefViaFqn& other) const {
    return std::tie(target,source)
             > std::tie(other.target,other.source);
  }
  bool operator>=(const XRefViaFqn& other) const {
    return std::tie(target,source)
             >= std::tie(other.target,other.source);
  }
  void outputRepr(Output<Repr<XRefViaFqn>> out) const {
    outputValue(out, std::make_tuple(target, source));
  }
}; // struct XRefViaFqn

struct XRefsViaFqnByFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::vector<XRefViaFqn>>> {
  static const char* GLEAN_name() {
    return "erlang.XRefsViaFqnByFile";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct XRefsViaFqnByFile

struct DeclarationComment : Predicate<std::tuple<Fact<FunctionDeclaration>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>>> {
  static const char* GLEAN_name() {
    return "erlang.DeclarationComment";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationComment

} // namespace Erlang

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Erlang::Declaration> {
  using Type = Sum<facebook::glean::cpp::schema::Erlang::FunctionDeclaration>;
};


namespace schema {

namespace Erlang {

struct Declaration {
  boost::variant<Alt<0, Fact<FunctionDeclaration>>> GLEAN_value;

  static Declaration func(const Fact<FunctionDeclaration>& a) {
    return Declaration{Alt<0, Fact<FunctionDeclaration>>(a)};
  }

  bool operator==(const Declaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Declaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Declaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Declaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Declaration

struct DeclarationLocation : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "erlang.DeclarationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationLocation

struct DeclarationReference : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "erlang.DeclarationReference";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationReference

struct DeclarationToFqn : Predicate<Declaration, Fqn> {
  static const char* GLEAN_name() {
    return "erlang.DeclarationToFqn";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationToFqn

struct DeclarationUses : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "erlang.DeclarationUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationUses

struct DeclarationWithFqn : Predicate<std::tuple<Fqn, Declaration>> {
  static const char* GLEAN_name() {
    return "erlang.DeclarationWithFqn";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationWithFqn

struct DeclarationsByFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, Declaration>> {
  static const char* GLEAN_name() {
    return "erlang.DeclarationsByFile";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationsByFile

struct SearchByName : Predicate<std::tuple<std::string, Declaration>> {
  static const char* GLEAN_name() {
    return "erlang.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchByName

} // namespace Erlang

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Dyn::Usage> {
  using Type = Enum<3>;
};


namespace schema {

namespace Dyn {

enum class Usage { Unused, Enumerated, Used };

struct ObserverIdentifier : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "dyn.ObserverIdentifier";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct ObserverIdentifier

} // namespace Dyn

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Dyn::Observer> {
  using Type = Sum<facebook::glean::cpp::schema::Dyn::ObserverIdentifier, facebook::glean::cpp::schema::Dyn::ObserverIdentifier>;
};


namespace schema {

namespace Dyn {

struct Observer {
  boost::variant<Alt<0, Fact<ObserverIdentifier>>, Alt<1, Fact<ObserverIdentifier>>> GLEAN_value;

  static Observer symbol(const Fact<ObserverIdentifier>& a) {
    return Observer{Alt<0, Fact<ObserverIdentifier>>(a)};
  }
  static Observer other(const Fact<ObserverIdentifier>& a) {
    return Observer{Alt<1, Fact<ObserverIdentifier>>(a)};
  }

  bool operator==(const Observer& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Observer& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Observer& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Observer& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Observer& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Observer& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Observer>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Observer

struct Environment : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "dyn.Environment";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct Environment

struct EntityDynamicReference : Predicate<std::tuple<Fact<EntityUsage>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "dyn.EntityDynamicReference";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct EntityDynamicReference

} // namespace Dyn

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Digest::Digest> {
  using Type = Tuple<String, Nat>;
};


namespace schema {

namespace Digest {

struct Digest {
  std::string hash;
  uint64_t size;

  bool operator==(const Digest& other) const {
    return std::tie(hash,size)
             == std::tie(other.hash,other.size);
  }
  bool operator!=(const Digest& other) const {
    return std::tie(hash,size)
             != std::tie(other.hash,other.size);
  }
  bool operator<(const Digest& other) const {
    return std::tie(hash,size)
             < std::tie(other.hash,other.size);
  }
  bool operator<=(const Digest& other) const {
    return std::tie(hash,size)
             <= std::tie(other.hash,other.size);
  }
  bool operator>(const Digest& other) const {
    return std::tie(hash,size)
             > std::tie(other.hash,other.size);
  }
  bool operator>=(const Digest& other) const {
    return std::tie(hash,size)
             >= std::tie(other.hash,other.size);
  }
  void outputRepr(Output<Repr<Digest>> out) const {
    outputValue(out, std::make_tuple(hash, size));
  }
}; // struct Digest

struct FileDigest : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Digest>> {
  static const char* GLEAN_name() {
    return "digest.FileDigest";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileDigest

} // namespace Digest

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Glass::FileMetadata> {
  using Type = Tuple<Bool, Maybe<facebook::glean::cpp::schema::Src::FileLines>, Maybe<Repr<facebook::glean::cpp::schema::Digest::Digest>>, Maybe<facebook::glean::cpp::schema::Src::IndexFailure>>;
};


namespace schema {

namespace Glass {

struct FileMetadata {
  bool indexed;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Src::FileLines>>> offsets;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Digest::Digest>> digest;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Src::IndexFailure>>> indexFailure;

  bool operator==(const FileMetadata& other) const {
    return std::tie(indexed,offsets,digest,indexFailure)
             == std::tie(other.indexed,other.offsets,other.digest,other.indexFailure);
  }
  bool operator!=(const FileMetadata& other) const {
    return std::tie(indexed,offsets,digest,indexFailure)
             != std::tie(other.indexed,other.offsets,other.digest,other.indexFailure);
  }
  bool operator<(const FileMetadata& other) const {
    return std::tie(indexed,offsets,digest,indexFailure)
             < std::tie(other.indexed,other.offsets,other.digest,other.indexFailure);
  }
  bool operator<=(const FileMetadata& other) const {
    return std::tie(indexed,offsets,digest,indexFailure)
             <= std::tie(other.indexed,other.offsets,other.digest,other.indexFailure);
  }
  bool operator>(const FileMetadata& other) const {
    return std::tie(indexed,offsets,digest,indexFailure)
             > std::tie(other.indexed,other.offsets,other.digest,other.indexFailure);
  }
  bool operator>=(const FileMetadata& other) const {
    return std::tie(indexed,offsets,digest,indexFailure)
             >= std::tie(other.indexed,other.offsets,other.digest,other.indexFailure);
  }
  void outputRepr(Output<Repr<FileMetadata>> out) const {
    outputValue(out, std::make_tuple(indexed, offsets, digest, indexFailure));
  }
}; // struct FileMetadata

struct FileInfo : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, FileMetadata>> {
  static const char* GLEAN_name() {
    return "glass.FileInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileInfo

} // namespace Glass

namespace Dataswarm {

struct TableDeclaration : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "dataswarm.TableDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TableDeclaration

struct TableColumnDeclaration : Predicate<std::tuple<std::string, std::string, std::string>> {
  static const char* GLEAN_name() {
    return "dataswarm.TableColumnDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TableColumnDeclaration

struct SubqueryDeclaration : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "dataswarm.SubqueryDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SubqueryDeclaration

struct SubqueryColumnDeclaration : Predicate<std::tuple<std::string, std::string, std::string>> {
  static const char* GLEAN_name() {
    return "dataswarm.SubqueryColumnDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SubqueryColumnDeclaration

struct MacroDeclaration : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "dataswarm.MacroDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct MacroDeclaration

} // namespace Dataswarm

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Dataswarm::Declaration> {
  using Type = Sum<facebook::glean::cpp::schema::Dataswarm::MacroDeclaration, facebook::glean::cpp::schema::Dataswarm::TableDeclaration, facebook::glean::cpp::schema::Dataswarm::SubqueryDeclaration, facebook::glean::cpp::schema::Dataswarm::TableColumnDeclaration, facebook::glean::cpp::schema::Dataswarm::SubqueryColumnDeclaration>;
};


namespace schema {

namespace Dataswarm {

struct Declaration {
  boost::variant<Alt<0, Fact<MacroDeclaration>>, Alt<1, Fact<TableDeclaration>>, Alt<2, Fact<SubqueryDeclaration>>, Alt<3, Fact<TableColumnDeclaration>>, Alt<4, Fact<SubqueryColumnDeclaration>>> GLEAN_value;

  static Declaration macro(const Fact<MacroDeclaration>& a) {
    return Declaration{Alt<0, Fact<MacroDeclaration>>(a)};
  }
  static Declaration table(const Fact<TableDeclaration>& a) {
    return Declaration{Alt<1, Fact<TableDeclaration>>(a)};
  }
  static Declaration subquery(const Fact<SubqueryDeclaration>& a) {
    return Declaration{Alt<2, Fact<SubqueryDeclaration>>(a)};
  }
  static Declaration table_column(const Fact<TableColumnDeclaration>& a) {
    return Declaration{Alt<3, Fact<TableColumnDeclaration>>(a)};
  }
  static Declaration subquery_column(const Fact<SubqueryColumnDeclaration>& a) {
    return Declaration{Alt<4, Fact<SubqueryColumnDeclaration>>(a)};
  }

  bool operator==(const Declaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Declaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Declaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Declaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Declaration

struct DeclarationLocation : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "dataswarm.DeclarationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationLocation

struct DeclarationName : Predicate<std::tuple<Declaration, std::string>> {
  static const char* GLEAN_name() {
    return "dataswarm.DeclarationName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationName

} // namespace Dataswarm

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Dataswarm::XRef> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Dataswarm::Declaration>, Repr<facebook::glean::cpp::schema::Src::ByteSpan>>;
};


namespace schema {

namespace Dataswarm {

struct XRef {
  Declaration target;
  facebook::glean::cpp::schema::Src::ByteSpan source;

  bool operator==(const XRef& other) const {
    return std::tie(target,source)
             == std::tie(other.target,other.source);
  }
  bool operator!=(const XRef& other) const {
    return std::tie(target,source)
             != std::tie(other.target,other.source);
  }
  bool operator<(const XRef& other) const {
    return std::tie(target,source)
             < std::tie(other.target,other.source);
  }
  bool operator<=(const XRef& other) const {
    return std::tie(target,source)
             <= std::tie(other.target,other.source);
  }
  bool operator>(const XRef& other) const {
    return std::tie(target,source)
             > std::tie(other.target,other.source);
  }
  bool operator>=(const XRef& other) const {
    return std::tie(target,source)
             >= std::tie(other.target,other.source);
  }
  void outputRepr(Output<Repr<XRef>> out) const {
    outputValue(out, std::make_tuple(target, source));
  }
}; // struct XRef

struct XRefsByFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::vector<XRef>>> {
  static const char* GLEAN_name() {
    return "dataswarm.XRefsByFile";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct XRefsByFile

} // namespace Dataswarm

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::XRefVia> {
  using Type = Sum<facebook::glean::cpp::schema::Cxx1::UsingDeclaration, facebook::glean::cpp::schema::Cxx1::UsingDirective, facebook::glean::cpp::schema::Pp1::Use>;
};


namespace schema {

namespace Cxx1 {

struct XRefVia {
  boost::variant<Alt<0, Fact<UsingDeclaration>>, Alt<1, Fact<UsingDirective>>, Alt<2, Fact<facebook::glean::cpp::schema::Pp1::Use>>> GLEAN_value;

  static XRefVia usingDeclaration(const Fact<UsingDeclaration>& a) {
    return XRefVia{Alt<0, Fact<UsingDeclaration>>(a)};
  }
  static XRefVia usingDirective(const Fact<UsingDirective>& a) {
    return XRefVia{Alt<1, Fact<UsingDirective>>(a)};
  }
  static XRefVia macro(const Fact<facebook::glean::cpp::schema::Pp1::Use>& a) {
    return XRefVia{Alt<2, Fact<facebook::glean::cpp::schema::Pp1::Use>>(a)};
  }

  bool operator==(const XRefVia& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const XRefVia& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const XRefVia& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const XRefVia& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const XRefVia& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const XRefVia& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<XRefVia>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct XRefVia

struct VariableLowerCase : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.VariableLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct VariableLowerCase

struct UsingDirective : Predicate<std::tuple<Fact<QName>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.UsingDirective";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct UsingDirective

struct UsingDeclaration : Predicate<std::tuple<Fact<FunctionQName>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.UsingDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct UsingDeclaration

using USR = std::string;

struct TypeAliasLowerCase : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.TypeAliasLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct TypeAliasLowerCase

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::TypeAliasKind> {
  using Type = Enum<2>;
};


namespace schema {

namespace Cxx1 {

enum class TypeAliasKind { Typedef, Using };

struct TypeAliasDeclaration : Predicate<std::tuple<Fact<QName>, Fact<Type>, TypeAliasKind, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.TypeAliasDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct TypeAliasDeclaration

struct Type : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "cxx1.Type";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct Type

struct TranslationUnitXRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Buck::TranslationUnit>, std::vector<Fact<FileXRefs>>>> {
  static const char* GLEAN_name() {
    return "cxx1.TranslationUnitXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct TranslationUnitXRefs

struct TranslationUnitTrace : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Buck::TranslationUnit>, Fact<Trace>>> {
  static const char* GLEAN_name() {
    return "cxx1.TranslationUnitTrace";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct TranslationUnitTrace

struct TranslationUnitIncludeTree : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Buck::TranslationUnit>, Fact<IncludeTree>>> {
  static const char* GLEAN_name() {
    return "cxx1.TranslationUnitIncludeTree";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct TranslationUnitIncludeTree

struct Trace : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Declarations>, Fact<PPTrace>>> {
  static const char* GLEAN_name() {
    return "cxx1.Trace";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct Trace

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::RefQualifier> {
  using Type = Enum<3>;
};


namespace schema {

namespace Cxx1 {

enum class RefQualifier { None_, LValue, RValue };

struct RecordUnionLowerCase : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.RecordUnionLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct RecordUnionLowerCase

struct RecordStructLowerCase : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.RecordStructLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct RecordStructLowerCase

struct RecordDerived : Predicate<std::tuple<Fact<RecordDeclaration>, Fact<RecordDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.RecordDerived";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct RecordDerived

struct RecordClassLowerCase : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.RecordClassLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct RecordClassLowerCase

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::PpEntity> {
  using Type = Sum<facebook::glean::cpp::schema::Pp1::Define, facebook::glean::cpp::schema::Pp1::Undef, facebook::glean::cpp::schema::Src::File>;
};


namespace schema {

namespace Cxx1 {

struct PpEntity {
  boost::variant<Alt<0, Fact<facebook::glean::cpp::schema::Pp1::Define>>, Alt<1, Fact<facebook::glean::cpp::schema::Pp1::Undef>>, Alt<2, Fact<facebook::glean::cpp::schema::Src::File>>> GLEAN_value;

  static PpEntity define(const Fact<facebook::glean::cpp::schema::Pp1::Define>& a) {
    return PpEntity{Alt<0, Fact<facebook::glean::cpp::schema::Pp1::Define>>(a)};
  }
  static PpEntity undef(const Fact<facebook::glean::cpp::schema::Pp1::Undef>& a) {
    return PpEntity{Alt<1, Fact<facebook::glean::cpp::schema::Pp1::Undef>>(a)};
  }
  static PpEntity include_(const Fact<facebook::glean::cpp::schema::Src::File>& a) {
    return PpEntity{Alt<2, Fact<facebook::glean::cpp::schema::Src::File>>(a)};
  }

  bool operator==(const PpEntity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const PpEntity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const PpEntity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const PpEntity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const PpEntity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const PpEntity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<PpEntity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct PpEntity

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::Parameter> {
  using Type = Tuple<facebook::glean::cpp::schema::Cxx1::Name, facebook::glean::cpp::schema::Cxx1::Type>;
};


namespace schema {

namespace Cxx1 {

struct Parameter {
  Fact<Name> name;
  Fact<Type> type;

  bool operator==(const Parameter& other) const {
    return std::tie(name,type)
             == std::tie(other.name,other.type);
  }
  bool operator!=(const Parameter& other) const {
    return std::tie(name,type)
             != std::tie(other.name,other.type);
  }
  bool operator<(const Parameter& other) const {
    return std::tie(name,type)
             < std::tie(other.name,other.type);
  }
  bool operator<=(const Parameter& other) const {
    return std::tie(name,type)
             <= std::tie(other.name,other.type);
  }
  bool operator>(const Parameter& other) const {
    return std::tie(name,type)
             > std::tie(other.name,other.type);
  }
  bool operator>=(const Parameter& other) const {
    return std::tie(name,type)
             >= std::tie(other.name,other.type);
  }
  void outputRepr(Output<Repr<Parameter>> out) const {
    outputValue(out, std::make_tuple(name, type));
  }
}; // struct Parameter

struct Signature : Predicate<std::tuple<Fact<Type>, std::vector<Parameter>>> {
  static const char* GLEAN_name() {
    return "cxx1.Signature";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct Signature

struct PPDefineLocation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Pp1::Define>, std::string, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.PPDefineLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct PPDefineLocation

using Operator = std::string;

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::ObjcSelectorSlot> {
  using Type = Tuple<facebook::glean::cpp::schema::Cxx1::ObjcMethodDeclaration, Nat>;
};


namespace schema {

namespace Cxx1 {

struct ObjcSelectorSlot {
  Fact<ObjcMethodDeclaration> objcMethod;
  uint64_t index;

  bool operator==(const ObjcSelectorSlot& other) const {
    return std::tie(objcMethod,index)
             == std::tie(other.objcMethod,other.index);
  }
  bool operator!=(const ObjcSelectorSlot& other) const {
    return std::tie(objcMethod,index)
             != std::tie(other.objcMethod,other.index);
  }
  bool operator<(const ObjcSelectorSlot& other) const {
    return std::tie(objcMethod,index)
             < std::tie(other.objcMethod,other.index);
  }
  bool operator<=(const ObjcSelectorSlot& other) const {
    return std::tie(objcMethod,index)
             <= std::tie(other.objcMethod,other.index);
  }
  bool operator>(const ObjcSelectorSlot& other) const {
    return std::tie(objcMethod,index)
             > std::tie(other.objcMethod,other.index);
  }
  bool operator>=(const ObjcSelectorSlot& other) const {
    return std::tie(objcMethod,index)
             >= std::tie(other.objcMethod,other.index);
  }
  void outputRepr(Output<Repr<ObjcSelectorSlot>> out) const {
    outputValue(out, std::make_tuple(objcMethod, index));
  }
}; // struct ObjcSelectorSlot

struct ObjcSelector : Predicate<std::vector<std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcSelector";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcSelector

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::ObjcPropertyKind> {
  using Type = Enum<2>;
};


namespace schema {

namespace Cxx1 {

enum class ObjcPropertyKind { Synthesize, Dynamic };

struct ObjcPropertyImplementation : Predicate<std::tuple<Fact<ObjcPropertyDeclaration>, ObjcPropertyKind, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Name>>>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcPropertyImplementation";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcPropertyImplementation

struct ObjcPropertyIVar : Predicate<std::tuple<Fact<ObjcPropertyDeclaration>, Fact<VariableDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcPropertyIVar";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcPropertyIVar

struct ObjcMethodDefinition : Predicate<Fact<ObjcMethodDeclaration>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcMethodDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcMethodDefinition

struct ObjcMethodDeclarationName : Predicate<std::tuple<Fact<ObjcMethodDeclaration>, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcMethodDeclarationName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcMethodDeclarationName

struct ObjcInterfaceToImplementation : Predicate<std::tuple<Fact<ObjcContainerDeclaration>, Fact<ObjcContainerDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcInterfaceToImplementation";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcInterfaceToImplementation

struct ObjcImplements : Predicate<std::tuple<Fact<ObjcContainerDeclaration>, Fact<ObjcContainerDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcImplements";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcImplements

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::ObjcIVar> {
  using Type = Tuple<Bool, Maybe<Nat>>;
};


namespace schema {

namespace Cxx1 {

struct ObjcIVar {
  bool synthesize;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, uint64_t>> bitsize;

  bool operator==(const ObjcIVar& other) const {
    return std::tie(synthesize,bitsize)
             == std::tie(other.synthesize,other.bitsize);
  }
  bool operator!=(const ObjcIVar& other) const {
    return std::tie(synthesize,bitsize)
             != std::tie(other.synthesize,other.bitsize);
  }
  bool operator<(const ObjcIVar& other) const {
    return std::tie(synthesize,bitsize)
             < std::tie(other.synthesize,other.bitsize);
  }
  bool operator<=(const ObjcIVar& other) const {
    return std::tie(synthesize,bitsize)
             <= std::tie(other.synthesize,other.bitsize);
  }
  bool operator>(const ObjcIVar& other) const {
    return std::tie(synthesize,bitsize)
             > std::tie(other.synthesize,other.bitsize);
  }
  bool operator>=(const ObjcIVar& other) const {
    return std::tie(synthesize,bitsize)
             >= std::tie(other.synthesize,other.bitsize);
  }
  void outputRepr(Output<Repr<ObjcIVar>> out) const {
    outputValue(out, std::make_tuple(synthesize, bitsize));
  }
}; // struct ObjcIVar

struct ObjcContainerInterfaceLowerCase : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcContainerInterfaceLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcContainerInterfaceLowerCase

struct ObjcContainerInheritance : Predicate<std::tuple<Fact<ObjcContainerDeclaration>, Fact<ObjcContainerDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcContainerInheritance";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcContainerInheritance

struct ObjcContainerDefinition : Predicate<std::tuple<Fact<ObjcContainerDeclaration>, std::vector<Fact<ObjcContainerDeclaration>>, Fact<Declarations>>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcContainerDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcContainerDefinition

struct ObjcContainerDeclarationInterface : Predicate<std::tuple<std::string, Fact<ObjcContainerDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcContainerDeclarationInterface";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcContainerDeclarationInterface

struct ObjcContainerBase : Predicate<std::tuple<Fact<ObjcContainerDeclaration>, Fact<ObjcContainerDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcContainerBase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcContainerBase

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::ObjcCategoryId> {
  using Type = Tuple<facebook::glean::cpp::schema::Cxx1::Name, facebook::glean::cpp::schema::Cxx1::Name>;
};


namespace schema {

namespace Cxx1 {

struct ObjcCategoryId {
  Fact<Name> className;
  Fact<Name> categoryName;

  bool operator==(const ObjcCategoryId& other) const {
    return std::tie(className,categoryName)
             == std::tie(other.className,other.categoryName);
  }
  bool operator!=(const ObjcCategoryId& other) const {
    return std::tie(className,categoryName)
             != std::tie(other.className,other.categoryName);
  }
  bool operator<(const ObjcCategoryId& other) const {
    return std::tie(className,categoryName)
             < std::tie(other.className,other.categoryName);
  }
  bool operator<=(const ObjcCategoryId& other) const {
    return std::tie(className,categoryName)
             <= std::tie(other.className,other.categoryName);
  }
  bool operator>(const ObjcCategoryId& other) const {
    return std::tie(className,categoryName)
             > std::tie(other.className,other.categoryName);
  }
  bool operator>=(const ObjcCategoryId& other) const {
    return std::tie(className,categoryName)
             >= std::tie(other.className,other.categoryName);
  }
  void outputRepr(Output<Repr<ObjcCategoryId>> out) const {
    outputValue(out, std::make_tuple(className, categoryName));
  }
}; // struct ObjcCategoryId

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::ObjcContainerId> {
  using Type = Sum<facebook::glean::cpp::schema::Cxx1::Name, facebook::glean::cpp::schema::Cxx1::Name, Repr<facebook::glean::cpp::schema::Cxx1::ObjcCategoryId>, facebook::glean::cpp::schema::Cxx1::Name, facebook::glean::cpp::schema::Cxx1::Name, Repr<facebook::glean::cpp::schema::Cxx1::ObjcCategoryId>>;
};


namespace schema {

namespace Cxx1 {

struct ObjcContainerId {
  boost::variant<Alt<0, Fact<Name>>, Alt<1, Fact<Name>>, Alt<2, ObjcCategoryId>, Alt<3, Fact<Name>>, Alt<4, Fact<Name>>, Alt<5, ObjcCategoryId>> GLEAN_value;

  static ObjcContainerId protocol(const Fact<Name>& a) {
    return ObjcContainerId{Alt<0, Fact<Name>>(a)};
  }
  static ObjcContainerId interface_(const Fact<Name>& a) {
    return ObjcContainerId{Alt<1, Fact<Name>>(a)};
  }
  static ObjcContainerId categoryInterface(const ObjcCategoryId& a) {
    return ObjcContainerId{Alt<2, ObjcCategoryId>(a)};
  }
  static ObjcContainerId extensionInterface(const Fact<Name>& a) {
    return ObjcContainerId{Alt<3, Fact<Name>>(a)};
  }
  static ObjcContainerId implementation(const Fact<Name>& a) {
    return ObjcContainerId{Alt<4, Fact<Name>>(a)};
  }
  static ObjcContainerId categoryImplementation(const ObjcCategoryId& a) {
    return ObjcContainerId{Alt<5, ObjcCategoryId>(a)};
  }

  bool operator==(const ObjcContainerId& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const ObjcContainerId& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const ObjcContainerId& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const ObjcContainerId& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const ObjcContainerId& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const ObjcContainerId& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<ObjcContainerId>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct ObjcContainerId

struct ObjcContainerDeclaration : Predicate<std::tuple<ObjcContainerId, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcContainerDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcContainerDeclaration

struct ObjcMethodDeclaration : Predicate<std::tuple<Fact<ObjcSelector>, std::vector<facebook::glean::cpp::schema::Src::FileLocation>, ObjcContainerId, Fact<Signature>, bool, bool, bool, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcMethodDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcMethodDeclaration

struct ObjcPropertyDeclaration : Predicate<std::tuple<Fact<Name>, ObjcContainerId, Fact<Type>, bool, bool, bool, bool, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjcPropertyDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjcPropertyDeclaration

struct ObjContainerIdName : Predicate<std::tuple<ObjcContainerId, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "cxx1.ObjContainerIdName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ObjContainerIdName

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::NamespaceTarget> {
  using Type = Sum<facebook::glean::cpp::schema::Cxx1::NamespaceDeclaration, facebook::glean::cpp::schema::Cxx1::NamespaceAliasDeclaration>;
};


namespace schema {

namespace Cxx1 {

struct NamespaceTarget {
  boost::variant<Alt<0, Fact<NamespaceDeclaration>>, Alt<1, Fact<NamespaceAliasDeclaration>>> GLEAN_value;

  static NamespaceTarget namespace_(const Fact<NamespaceDeclaration>& a) {
    return NamespaceTarget{Alt<0, Fact<NamespaceDeclaration>>(a)};
  }
  static NamespaceTarget namespaceAlias(const Fact<NamespaceAliasDeclaration>& a) {
    return NamespaceTarget{Alt<1, Fact<NamespaceAliasDeclaration>>(a)};
  }

  bool operator==(const NamespaceTarget& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const NamespaceTarget& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const NamespaceTarget& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const NamespaceTarget& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const NamespaceTarget& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const NamespaceTarget& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<NamespaceTarget>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct NamespaceTarget

struct NamespaceQName : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Name>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>>> {
  static const char* GLEAN_name() {
    return "cxx1.NamespaceQName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct NamespaceQName

struct NamespaceLowerCase : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.NamespaceLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct NamespaceLowerCase

struct NamespaceDefinition : Predicate<std::tuple<Fact<NamespaceDeclaration>, Fact<Declarations>>> {
  static const char* GLEAN_name() {
    return "cxx1.NamespaceDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct NamespaceDefinition

struct NamespaceDeclarationName : Predicate<std::tuple<Fact<NamespaceQName>, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "cxx1.NamespaceDeclarationName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct NamespaceDeclarationName

struct NamespaceDeclarationByName : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>>, Fact<NamespaceDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.NamespaceDeclarationByName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct NamespaceDeclarationByName

struct NamespaceDeclaration : Predicate<std::tuple<Fact<NamespaceQName>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.NamespaceDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct NamespaceDeclaration

struct NamespaceAliasDeclaration : Predicate<std::tuple<Fact<NamespaceQName>, NamespaceTarget, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.NamespaceAliasDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct NamespaceAliasDeclaration

struct Name : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "cxx1.Name";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct Name

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::MethodSignature> {
  using Type = Tuple<Bool, Bool, Bool, Repr<facebook::glean::cpp::schema::Cxx1::RefQualifier>>;
};


namespace schema {

namespace Cxx1 {

struct MethodSignature {
  bool isVirtual;
  bool isConst;
  bool isVolatile;
  RefQualifier refQualifier;

  bool operator==(const MethodSignature& other) const {
    return std::tie(isVirtual,isConst,isVolatile,refQualifier)
             == std::tie(other.isVirtual,other.isConst,other.isVolatile,other.refQualifier);
  }
  bool operator!=(const MethodSignature& other) const {
    return std::tie(isVirtual,isConst,isVolatile,refQualifier)
             != std::tie(other.isVirtual,other.isConst,other.isVolatile,other.refQualifier);
  }
  bool operator<(const MethodSignature& other) const {
    return std::tie(isVirtual,isConst,isVolatile,refQualifier)
             < std::tie(other.isVirtual,other.isConst,other.isVolatile,other.refQualifier);
  }
  bool operator<=(const MethodSignature& other) const {
    return std::tie(isVirtual,isConst,isVolatile,refQualifier)
             <= std::tie(other.isVirtual,other.isConst,other.isVolatile,other.refQualifier);
  }
  bool operator>(const MethodSignature& other) const {
    return std::tie(isVirtual,isConst,isVolatile,refQualifier)
             > std::tie(other.isVirtual,other.isConst,other.isVolatile,other.refQualifier);
  }
  bool operator>=(const MethodSignature& other) const {
    return std::tie(isVirtual,isConst,isVolatile,refQualifier)
             >= std::tie(other.isVirtual,other.isConst,other.isVolatile,other.refQualifier);
  }
  void outputRepr(Output<Repr<MethodSignature>> out) const {
    outputValue(out, std::make_tuple(isVirtual, isConst, isVolatile, refQualifier));
  }
}; // struct MethodSignature

struct MethodOverrides : Predicate<std::tuple<Fact<FunctionDeclaration>, Fact<FunctionDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.MethodOverrides";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct MethodOverrides

struct MethodOverridden : Predicate<std::tuple<Fact<FunctionDeclaration>, Fact<FunctionDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.MethodOverridden";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct MethodOverridden

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::MaybeIncludeTree> {
  using Type = Tuple<Maybe<facebook::glean::cpp::schema::Cxx1::IncludeTree>>;
};


namespace schema {

namespace Cxx1 {

struct MaybeIncludeTree {
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<IncludeTree>>> tree;

  bool operator==(const MaybeIncludeTree& other) const {
    return std::tie(tree)
             == std::tie(other.tree);
  }
  bool operator!=(const MaybeIncludeTree& other) const {
    return std::tie(tree)
             != std::tie(other.tree);
  }
  bool operator<(const MaybeIncludeTree& other) const {
    return std::tie(tree)
             < std::tie(other.tree);
  }
  bool operator<=(const MaybeIncludeTree& other) const {
    return std::tie(tree)
             <= std::tie(other.tree);
  }
  bool operator>(const MaybeIncludeTree& other) const {
    return std::tie(tree)
             > std::tie(other.tree);
  }
  bool operator>=(const MaybeIncludeTree& other) const {
    return std::tie(tree)
             >= std::tie(other.tree);
  }
  void outputRepr(Output<Repr<MaybeIncludeTree>> out) const {
    outputValue(out, std::make_tuple(tree));
  }
}; // struct MaybeIncludeTree

using MangledNameHash = std::string;

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::LocalVariableKind> {
  using Type = Enum<3>;
};


namespace schema {

namespace Cxx1 {

enum class LocalVariableKind { SimpleVariable, StaticVariable, Parameter };

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::LocalVariableAttribute> {
  using Type = Enum<2>;
};


namespace schema {

namespace Cxx1 {

enum class LocalVariableAttribute { Plain, Constexpr };

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::LocalVariable> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Cxx1::LocalVariableKind>, Repr<facebook::glean::cpp::schema::Cxx1::LocalVariableAttribute>>;
};


namespace schema {

namespace Cxx1 {

struct LocalVariable {
  LocalVariableKind kind;
  LocalVariableAttribute attribute;

  bool operator==(const LocalVariable& other) const {
    return std::tie(kind,attribute)
             == std::tie(other.kind,other.attribute);
  }
  bool operator!=(const LocalVariable& other) const {
    return std::tie(kind,attribute)
             != std::tie(other.kind,other.attribute);
  }
  bool operator<(const LocalVariable& other) const {
    return std::tie(kind,attribute)
             < std::tie(other.kind,other.attribute);
  }
  bool operator<=(const LocalVariable& other) const {
    return std::tie(kind,attribute)
             <= std::tie(other.kind,other.attribute);
  }
  bool operator>(const LocalVariable& other) const {
    return std::tie(kind,attribute)
             > std::tie(other.kind,other.attribute);
  }
  bool operator>=(const LocalVariable& other) const {
    return std::tie(kind,attribute)
             >= std::tie(other.kind,other.attribute);
  }
  void outputRepr(Output<Repr<LocalVariable>> out) const {
    outputValue(out, std::make_tuple(kind, attribute));
  }
}; // struct LocalVariable

using LiteralOperator = std::string;

struct IncludeTreeTranslationUnit : Predicate<std::tuple<Fact<IncludeTree>, Fact<facebook::glean::cpp::schema::Buck::TranslationUnit>>> {
  static const char* GLEAN_name() {
    return "cxx1.IncludeTreeTranslationUnit";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct IncludeTreeTranslationUnit

struct IncludeTreeParent : Predicate<std::tuple<Fact<IncludeTree>, Fact<IncludeTree>>> {
  static const char* GLEAN_name() {
    return "cxx1.IncludeTreeParent";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct IncludeTreeParent

struct IncludeTree : Predicate<std::tuple<Fact<Trace>, std::vector<MaybeIncludeTree>>> {
  static const char* GLEAN_name() {
    return "cxx1.IncludeTree";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct IncludeTree

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::IncludeTrace> {
  using Type = Tuple<facebook::glean::cpp::schema::Pp1::Include, Maybe<facebook::glean::cpp::schema::Cxx1::Trace>>;
};


namespace schema {

namespace Cxx1 {

struct IncludeTrace {
  Fact<facebook::glean::cpp::schema::Pp1::Include> include_;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Trace>>> trace;

  bool operator==(const IncludeTrace& other) const {
    return std::tie(include_,trace)
             == std::tie(other.include_,other.trace);
  }
  bool operator!=(const IncludeTrace& other) const {
    return std::tie(include_,trace)
             != std::tie(other.include_,other.trace);
  }
  bool operator<(const IncludeTrace& other) const {
    return std::tie(include_,trace)
             < std::tie(other.include_,other.trace);
  }
  bool operator<=(const IncludeTrace& other) const {
    return std::tie(include_,trace)
             <= std::tie(other.include_,other.trace);
  }
  bool operator>(const IncludeTrace& other) const {
    return std::tie(include_,trace)
             > std::tie(other.include_,other.trace);
  }
  bool operator>=(const IncludeTrace& other) const {
    return std::tie(include_,trace)
             >= std::tie(other.include_,other.trace);
  }
  void outputRepr(Output<Repr<IncludeTrace>> out) const {
    outputValue(out, std::make_tuple(include_, trace));
  }
}; // struct IncludeTrace

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::PPEvent> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Cxx1::IncludeTrace>, facebook::glean::cpp::schema::Pp1::Define, facebook::glean::cpp::schema::Pp1::Undef, facebook::glean::cpp::schema::Pp1::Use>;
};


namespace schema {

namespace Cxx1 {

struct PPEvent {
  boost::variant<Alt<0, IncludeTrace>, Alt<1, Fact<facebook::glean::cpp::schema::Pp1::Define>>, Alt<2, Fact<facebook::glean::cpp::schema::Pp1::Undef>>, Alt<3, Fact<facebook::glean::cpp::schema::Pp1::Use>>> GLEAN_value;

  static PPEvent include_(const IncludeTrace& a) {
    return PPEvent{Alt<0, IncludeTrace>(a)};
  }
  static PPEvent define(const Fact<facebook::glean::cpp::schema::Pp1::Define>& a) {
    return PPEvent{Alt<1, Fact<facebook::glean::cpp::schema::Pp1::Define>>(a)};
  }
  static PPEvent undef(const Fact<facebook::glean::cpp::schema::Pp1::Undef>& a) {
    return PPEvent{Alt<2, Fact<facebook::glean::cpp::schema::Pp1::Undef>>(a)};
  }
  static PPEvent use(const Fact<facebook::glean::cpp::schema::Pp1::Use>& a) {
    return PPEvent{Alt<3, Fact<facebook::glean::cpp::schema::Pp1::Use>>(a)};
  }

  bool operator==(const PPEvent& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const PPEvent& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const PPEvent& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const PPEvent& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const PPEvent& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const PPEvent& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<PPEvent>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct PPEvent

struct PPTrace : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::vector<PPEvent>>> {
  static const char* GLEAN_name() {
    return "cxx1.PPTrace";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct PPTrace

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::GlobalVariableKind> {
  using Type = Enum<3>;
};


namespace schema {

namespace Cxx1 {

enum class GlobalVariableKind { SimpleVariable, StaticVariable, StaticMember };

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::GlobalVariableAttribute> {
  using Type = Enum<3>;
};


namespace schema {

namespace Cxx1 {

enum class GlobalVariableAttribute { Plain, Inline, Constexpr };

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::GlobalVariable> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Cxx1::GlobalVariableKind>, Repr<facebook::glean::cpp::schema::Cxx1::GlobalVariableAttribute>, Bool>;
};


namespace schema {

namespace Cxx1 {

struct GlobalVariable {
  GlobalVariableKind kind;
  GlobalVariableAttribute attribute;
  bool definition;

  bool operator==(const GlobalVariable& other) const {
    return std::tie(kind,attribute,definition)
             == std::tie(other.kind,other.attribute,other.definition);
  }
  bool operator!=(const GlobalVariable& other) const {
    return std::tie(kind,attribute,definition)
             != std::tie(other.kind,other.attribute,other.definition);
  }
  bool operator<(const GlobalVariable& other) const {
    return std::tie(kind,attribute,definition)
             < std::tie(other.kind,other.attribute,other.definition);
  }
  bool operator<=(const GlobalVariable& other) const {
    return std::tie(kind,attribute,definition)
             <= std::tie(other.kind,other.attribute,other.definition);
  }
  bool operator>(const GlobalVariable& other) const {
    return std::tie(kind,attribute,definition)
             > std::tie(other.kind,other.attribute,other.definition);
  }
  bool operator>=(const GlobalVariable& other) const {
    return std::tie(kind,attribute,definition)
             >= std::tie(other.kind,other.attribute,other.definition);
  }
  void outputRepr(Output<Repr<GlobalVariable>> out) const {
    outputValue(out, std::make_tuple(kind, attribute, definition));
  }
}; // struct GlobalVariable

struct FunctionLowerCase : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.FunctionLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FunctionLowerCase

struct FunctionDefinition : Predicate<std::tuple<Fact<FunctionDeclaration>, bool>> {
  static const char* GLEAN_name() {
    return "cxx1.FunctionDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FunctionDefinition

struct FunctionDeclarationNameString : Predicate<std::tuple<Fact<FunctionName>, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.FunctionDeclarationNameString";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FunctionDeclarationNameString

struct FunctionDeclarationName : Predicate<std::tuple<Fact<FunctionName>, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "cxx1.FunctionDeclarationName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FunctionDeclarationName

struct FunctionDeclaration : Predicate<std::tuple<Fact<FunctionQName>, Fact<Signature>, boost::variant<Alt<0, std::tuple<>>, Alt<1, MethodSignature>>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.FunctionDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FunctionDeclaration

struct FunctionDeclAttribute : Predicate<std::tuple<Fact<FunctionDeclaration>, Fact<Attribute>>> {
  static const char* GLEAN_name() {
    return "cxx1.FunctionDeclAttribute";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FunctionDeclAttribute

struct FunctionAttribute : Predicate<std::tuple<Fact<Attribute>, Fact<FunctionDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.FunctionAttribute";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FunctionAttribute

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::From> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Src::PackedByteSpans>, Repr<facebook::glean::cpp::schema::Src::PackedByteSpans>, Repr<facebook::glean::cpp::schema::Src::PackedByteSpans>>;
};


namespace schema {

namespace Cxx1 {

struct From {
  facebook::glean::cpp::schema::Src::PackedByteSpans spans;
  facebook::glean::cpp::schema::Src::PackedByteSpans expansions;
  facebook::glean::cpp::schema::Src::PackedByteSpans spellings;

  bool operator==(const From& other) const {
    return std::tie(spans,expansions,spellings)
             == std::tie(other.spans,other.expansions,other.spellings);
  }
  bool operator!=(const From& other) const {
    return std::tie(spans,expansions,spellings)
             != std::tie(other.spans,other.expansions,other.spellings);
  }
  bool operator<(const From& other) const {
    return std::tie(spans,expansions,spellings)
             < std::tie(other.spans,other.expansions,other.spellings);
  }
  bool operator<=(const From& other) const {
    return std::tie(spans,expansions,spellings)
             <= std::tie(other.spans,other.expansions,other.spellings);
  }
  bool operator>(const From& other) const {
    return std::tie(spans,expansions,spellings)
             > std::tie(other.spans,other.expansions,other.spellings);
  }
  bool operator>=(const From& other) const {
    return std::tie(spans,expansions,spellings)
             >= std::tie(other.spans,other.expansions,other.spellings);
  }
  void outputRepr(Output<Repr<From>> out) const {
    outputValue(out, std::make_tuple(spans, expansions, spellings));
  }
}; // struct From

struct FileXRefs : Predicate<std::tuple<Fact<FileXRefMap>, std::vector<Fact<XRefTargets>>>> {
  static const char* GLEAN_name() {
    return "cxx1.FileXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FileXRefs

struct FilePPUseXRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::Range, Fact<facebook::glean::cpp::schema::Pp1::Define>>> {
  static const char* GLEAN_name() {
    return "cxx1.FilePPUseXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FilePPUseXRefs

struct FilePPUseTraceXRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Trace>, facebook::glean::cpp::schema::Src::Range, Fact<facebook::glean::cpp::schema::Pp1::Define>>> {
  static const char* GLEAN_name() {
    return "cxx1.FilePPUseTraceXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FilePPUseTraceXRefs

struct FilePPTraceXRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Trace>, facebook::glean::cpp::schema::Src::Range, PpEntity, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "cxx1.FilePPTraceXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FilePPTraceXRefs

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::Field> {
  using Type = Tuple<Bool, Maybe<Nat>>;
};


namespace schema {

namespace Cxx1 {

struct Field {
  bool mutable_;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, uint64_t>> bitsize;

  bool operator==(const Field& other) const {
    return std::tie(mutable_,bitsize)
             == std::tie(other.mutable_,other.bitsize);
  }
  bool operator!=(const Field& other) const {
    return std::tie(mutable_,bitsize)
             != std::tie(other.mutable_,other.bitsize);
  }
  bool operator<(const Field& other) const {
    return std::tie(mutable_,bitsize)
             < std::tie(other.mutable_,other.bitsize);
  }
  bool operator<=(const Field& other) const {
    return std::tie(mutable_,bitsize)
             <= std::tie(other.mutable_,other.bitsize);
  }
  bool operator>(const Field& other) const {
    return std::tie(mutable_,bitsize)
             > std::tie(other.mutable_,other.bitsize);
  }
  bool operator>=(const Field& other) const {
    return std::tie(mutable_,bitsize)
             >= std::tie(other.mutable_,other.bitsize);
  }
  void outputRepr(Output<Repr<Field>> out) const {
    outputValue(out, std::make_tuple(mutable_, bitsize));
  }
}; // struct Field

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::VariableKind> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Cxx1::GlobalVariable>, Repr<facebook::glean::cpp::schema::Cxx1::LocalVariable>, Repr<facebook::glean::cpp::schema::Cxx1::Field>, Repr<facebook::glean::cpp::schema::Cxx1::ObjcIVar>>;
};


namespace schema {

namespace Cxx1 {

struct VariableKind {
  boost::variant<Alt<0, GlobalVariable>, Alt<1, LocalVariable>, Alt<2, Field>, Alt<3, ObjcIVar>> GLEAN_value;

  static VariableKind global_(const GlobalVariable& a) {
    return VariableKind{Alt<0, GlobalVariable>(a)};
  }
  static VariableKind local(const LocalVariable& a) {
    return VariableKind{Alt<1, LocalVariable>(a)};
  }
  static VariableKind field(const Field& a) {
    return VariableKind{Alt<2, Field>(a)};
  }
  static VariableKind ivar(const ObjcIVar& a) {
    return VariableKind{Alt<3, ObjcIVar>(a)};
  }

  bool operator==(const VariableKind& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const VariableKind& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const VariableKind& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const VariableKind& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const VariableKind& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const VariableKind& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<VariableKind>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct VariableKind

struct VariableDeclaration : Predicate<std::tuple<Fact<QName>, Fact<Type>, VariableKind, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.VariableDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct VariableDeclaration

struct EnumeratorLowerCase : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.EnumeratorLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct EnumeratorLowerCase

struct EnumeratorInEnum : Predicate<std::tuple<Fact<Enumerator>, Fact<EnumDefinition>>> {
  static const char* GLEAN_name() {
    return "cxx1.EnumeratorInEnum";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct EnumeratorInEnum

struct EnumeratorByName : Predicate<std::tuple<std::string, Fact<Enumerator>>> {
  static const char* GLEAN_name() {
    return "cxx1.EnumeratorByName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct EnumeratorByName

struct Enumerator : Predicate<std::tuple<Fact<Name>, Fact<EnumDeclaration>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.Enumerator";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct Enumerator

struct EnumLowerCase : Predicate<std::tuple<std::string, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.EnumLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct EnumLowerCase

struct EnumDefinition : Predicate<std::tuple<Fact<EnumDeclaration>, std::vector<Fact<Enumerator>>>> {
  static const char* GLEAN_name() {
    return "cxx1.EnumDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct EnumDefinition

struct EnumDeclaration : Predicate<std::tuple<Fact<QName>, bool, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Type>>>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.EnumDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct EnumDeclaration

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::DefinitionEntity> {
  using Type = Sum<facebook::glean::cpp::schema::Cxx1::RecordDefinition, facebook::glean::cpp::schema::Cxx1::FunctionDefinition, facebook::glean::cpp::schema::Cxx1::EnumDefinition, facebook::glean::cpp::schema::Cxx1::ObjcMethodDefinition, facebook::glean::cpp::schema::Cxx1::ObjcContainerDefinition, facebook::glean::cpp::schema::Cxx1::VariableDeclaration, facebook::glean::cpp::schema::Cxx1::NamespaceDefinition>;
};


namespace schema {

namespace Cxx1 {

struct DefinitionEntity {
  boost::variant<Alt<0, Fact<RecordDefinition>>, Alt<1, Fact<FunctionDefinition>>, Alt<2, Fact<EnumDefinition>>, Alt<3, Fact<ObjcMethodDefinition>>, Alt<4, Fact<ObjcContainerDefinition>>, Alt<5, Fact<VariableDeclaration>>, Alt<6, Fact<NamespaceDefinition>>> GLEAN_value;

  static DefinitionEntity record_(const Fact<RecordDefinition>& a) {
    return DefinitionEntity{Alt<0, Fact<RecordDefinition>>(a)};
  }
  static DefinitionEntity function_(const Fact<FunctionDefinition>& a) {
    return DefinitionEntity{Alt<1, Fact<FunctionDefinition>>(a)};
  }
  static DefinitionEntity enum_(const Fact<EnumDefinition>& a) {
    return DefinitionEntity{Alt<2, Fact<EnumDefinition>>(a)};
  }
  static DefinitionEntity objcMethod(const Fact<ObjcMethodDefinition>& a) {
    return DefinitionEntity{Alt<3, Fact<ObjcMethodDefinition>>(a)};
  }
  static DefinitionEntity objcContainer(const Fact<ObjcContainerDefinition>& a) {
    return DefinitionEntity{Alt<4, Fact<ObjcContainerDefinition>>(a)};
  }
  static DefinitionEntity variable(const Fact<VariableDeclaration>& a) {
    return DefinitionEntity{Alt<5, Fact<VariableDeclaration>>(a)};
  }
  static DefinitionEntity namespace_(const Fact<NamespaceDefinition>& a) {
    return DefinitionEntity{Alt<6, Fact<NamespaceDefinition>>(a)};
  }

  bool operator==(const DefinitionEntity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const DefinitionEntity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const DefinitionEntity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const DefinitionEntity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const DefinitionEntity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const DefinitionEntity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<DefinitionEntity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct DefinitionEntity

struct DefnInRecord : Predicate<std::tuple<DefinitionEntity, Fact<RecordDefinition>>> {
  static const char* GLEAN_name() {
    return "cxx1.DefnInRecord";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DefnInRecord

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::Declaration> {
  using Type = Sum<facebook::glean::cpp::schema::Cxx1::NamespaceDeclaration, facebook::glean::cpp::schema::Cxx1::UsingDeclaration, facebook::glean::cpp::schema::Cxx1::UsingDirective, facebook::glean::cpp::schema::Cxx1::RecordDeclaration, facebook::glean::cpp::schema::Cxx1::EnumDeclaration, facebook::glean::cpp::schema::Cxx1::FunctionDeclaration, facebook::glean::cpp::schema::Cxx1::VariableDeclaration, facebook::glean::cpp::schema::Cxx1::ObjcContainerDeclaration, facebook::glean::cpp::schema::Cxx1::ObjcMethodDeclaration, facebook::glean::cpp::schema::Cxx1::ObjcPropertyDeclaration, facebook::glean::cpp::schema::Cxx1::TypeAliasDeclaration, facebook::glean::cpp::schema::Cxx1::NamespaceAliasDeclaration>;
};


namespace schema {

namespace Cxx1 {

struct Declaration {
  boost::variant<Alt<0, Fact<NamespaceDeclaration>>, Alt<1, Fact<UsingDeclaration>>, Alt<2, Fact<UsingDirective>>, Alt<3, Fact<RecordDeclaration>>, Alt<4, Fact<EnumDeclaration>>, Alt<5, Fact<FunctionDeclaration>>, Alt<6, Fact<VariableDeclaration>>, Alt<7, Fact<ObjcContainerDeclaration>>, Alt<8, Fact<ObjcMethodDeclaration>>, Alt<9, Fact<ObjcPropertyDeclaration>>, Alt<10, Fact<TypeAliasDeclaration>>, Alt<11, Fact<NamespaceAliasDeclaration>>> GLEAN_value;

  static Declaration namespace_(const Fact<NamespaceDeclaration>& a) {
    return Declaration{Alt<0, Fact<NamespaceDeclaration>>(a)};
  }
  static Declaration usingDeclaration(const Fact<UsingDeclaration>& a) {
    return Declaration{Alt<1, Fact<UsingDeclaration>>(a)};
  }
  static Declaration usingDirective(const Fact<UsingDirective>& a) {
    return Declaration{Alt<2, Fact<UsingDirective>>(a)};
  }
  static Declaration record_(const Fact<RecordDeclaration>& a) {
    return Declaration{Alt<3, Fact<RecordDeclaration>>(a)};
  }
  static Declaration enum_(const Fact<EnumDeclaration>& a) {
    return Declaration{Alt<4, Fact<EnumDeclaration>>(a)};
  }
  static Declaration function_(const Fact<FunctionDeclaration>& a) {
    return Declaration{Alt<5, Fact<FunctionDeclaration>>(a)};
  }
  static Declaration variable(const Fact<VariableDeclaration>& a) {
    return Declaration{Alt<6, Fact<VariableDeclaration>>(a)};
  }
  static Declaration objcContainer(const Fact<ObjcContainerDeclaration>& a) {
    return Declaration{Alt<7, Fact<ObjcContainerDeclaration>>(a)};
  }
  static Declaration objcMethod(const Fact<ObjcMethodDeclaration>& a) {
    return Declaration{Alt<8, Fact<ObjcMethodDeclaration>>(a)};
  }
  static Declaration objcProperty(const Fact<ObjcPropertyDeclaration>& a) {
    return Declaration{Alt<9, Fact<ObjcPropertyDeclaration>>(a)};
  }
  static Declaration typeAlias(const Fact<TypeAliasDeclaration>& a) {
    return Declaration{Alt<10, Fact<TypeAliasDeclaration>>(a)};
  }
  static Declaration namespaceAlias(const Fact<NamespaceAliasDeclaration>& a) {
    return Declaration{Alt<11, Fact<NamespaceAliasDeclaration>>(a)};
  }

  bool operator==(const Declaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Declaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Declaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Declaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Declaration

struct DeclarationComment : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclarationComment";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclarationComment

struct DeclarationInTrace : Predicate<std::tuple<Declaration, Fact<Trace>>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclarationInTrace";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclarationInTrace

struct DeclarationLocationName : Predicate<std::tuple<Declaration, facebook::glean::cpp::schema::Src::Range, std::string>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclarationLocationName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclarationLocationName

struct DeclarationLocationNameSpan : Predicate<std::tuple<Declaration, facebook::glean::cpp::schema::Src::Range, std::string, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclarationLocationNameSpan";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclarationLocationNameSpan

struct DeclarationNameSpan : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclarationNameSpan";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclarationNameSpan

struct DeclarationSources : Predicate<std::tuple<Declaration, std::vector<Declaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclarationSources";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclarationSources

struct DeclarationSrcRange : Predicate<std::tuple<Declaration, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclarationSrcRange";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclarationSrcRange

struct DeclarationTargets : Predicate<std::tuple<Declaration, std::vector<Declaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclarationTargets";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclarationTargets

struct DeclarationToUSR : Predicate<std::tuple<Declaration, USR>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclarationToUSR";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclarationToUSR

struct Declarations : Predicate<std::vector<Declaration>> {
  static const char* GLEAN_name() {
    return "cxx1.Declarations";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct Declarations

struct DefToBaseDecl : Predicate<std::tuple<DefinitionEntity, Declaration>> {
  static const char* GLEAN_name() {
    return "cxx1.DefToBaseDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DefToBaseDecl

struct MangledNameHashToDeclaration : Predicate<std::tuple<MangledNameHash, Declaration>> {
  static const char* GLEAN_name() {
    return "cxx1.MangledNameHashToDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct MangledNameHashToDeclaration

struct Same : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "cxx1.Same";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct Same

struct USRToDeclaration : Predicate<std::tuple<USR, Declaration>> {
  static const char* GLEAN_name() {
    return "cxx1.USRToDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct USRToDeclaration

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::XRefTarget> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Cxx1::Declaration>, facebook::glean::cpp::schema::Cxx1::Enumerator, facebook::glean::cpp::schema::Cxx1::ObjcSelector, Repr<facebook::glean::cpp::schema::Cxx1::ObjcSelectorSlot>, Repr<facebook::glean::cpp::schema::Src::Loc>, facebook::glean::cpp::schema::Cxx1::XRefIndirectTarget>;
};


namespace schema {

namespace Cxx1 {

struct XRefTarget {
  boost::variant<Alt<0, Declaration>, Alt<1, Fact<Enumerator>>, Alt<2, Fact<ObjcSelector>>, Alt<3, ObjcSelectorSlot>, Alt<4, facebook::glean::cpp::schema::Src::Loc>, Alt<5, Fact<XRefIndirectTarget>>> GLEAN_value;

  static XRefTarget declaration(const Declaration& a) {
    return XRefTarget{Alt<0, Declaration>(a)};
  }
  static XRefTarget enumerator(const Fact<Enumerator>& a) {
    return XRefTarget{Alt<1, Fact<Enumerator>>(a)};
  }
  static XRefTarget objcSelector(const Fact<ObjcSelector>& a) {
    return XRefTarget{Alt<2, Fact<ObjcSelector>>(a)};
  }
  static XRefTarget objcSelectorSlot(const ObjcSelectorSlot& a) {
    return XRefTarget{Alt<3, ObjcSelectorSlot>(a)};
  }
  static XRefTarget unknown(const facebook::glean::cpp::schema::Src::Loc& a) {
    return XRefTarget{Alt<4, facebook::glean::cpp::schema::Src::Loc>(a)};
  }
  static XRefTarget indirect(const Fact<XRefIndirectTarget>& a) {
    return XRefTarget{Alt<5, Fact<XRefIndirectTarget>>(a)};
  }

  bool operator==(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const XRefTarget& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<XRefTarget>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct XRefTarget

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::FixedXRef> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Cxx1::XRefTarget>, Repr<facebook::glean::cpp::schema::Cxx1::From>>;
};


namespace schema {

namespace Cxx1 {

struct FixedXRef {
  XRefTarget target;
  From from;

  bool operator==(const FixedXRef& other) const {
    return std::tie(target,from)
             == std::tie(other.target,other.from);
  }
  bool operator!=(const FixedXRef& other) const {
    return std::tie(target,from)
             != std::tie(other.target,other.from);
  }
  bool operator<(const FixedXRef& other) const {
    return std::tie(target,from)
             < std::tie(other.target,other.from);
  }
  bool operator<=(const FixedXRef& other) const {
    return std::tie(target,from)
             <= std::tie(other.target,other.from);
  }
  bool operator>(const FixedXRef& other) const {
    return std::tie(target,from)
             > std::tie(other.target,other.from);
  }
  bool operator>=(const FixedXRef& other) const {
    return std::tie(target,from)
             >= std::tie(other.target,other.from);
  }
  void outputRepr(Output<Repr<FixedXRef>> out) const {
    outputValue(out, std::make_tuple(target, from));
  }
}; // struct FixedXRef

struct FileXRefMap : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::vector<FixedXRef>, std::vector<From>>> {
  static const char* GLEAN_name() {
    return "cxx1.FileXRefMap";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FileXRefMap

struct SpellingXRef : Predicate<std::tuple<facebook::glean::cpp::schema::Src::FileLocation, XRefTarget>> {
  static const char* GLEAN_name() {
    return "cxx1.SpellingXRef";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct SpellingXRef

struct TargetUses : Predicate<std::tuple<XRefTarget, Fact<facebook::glean::cpp::schema::Src::File>, From>> {
  static const char* GLEAN_name() {
    return "cxx1.TargetUses";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct TargetUses

struct ThriftToCxx : Predicate<std::tuple<facebook::glean::cpp::schema::Fbthrift::Declaration, XRefTarget>> {
  static const char* GLEAN_name() {
    return "cxx1.ThriftToCxx";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct ThriftToCxx

struct XRefIndirectTarget : Predicate<std::tuple<XRefVia, XRefTarget>> {
  static const char* GLEAN_name() {
    return "cxx1.XRefIndirectTarget";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct XRefIndirectTarget

struct XRefTargets : Predicate<std::vector<XRefTarget>> {
  static const char* GLEAN_name() {
    return "cxx1.XRefTargets";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct XRefTargets

} // namespace Cxx1

namespace Symbolid {

namespace Cxx {

struct LookupNamespaceDeclaration : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Cxx1::Name>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Cxx1::NamespaceQName>>>, facebook::glean::cpp::schema::Cxx1::Declaration>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.LookupNamespaceDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupNamespaceDeclaration

} // namespace Cxx

} // namespace Symbolid

namespace Cxx1 {

struct DeclToFamily : Predicate<std::tuple<Declaration, Fact<DeclFamily>>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclToFamily";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclToFamily

struct DeclInRecord : Predicate<std::tuple<Declaration, Fact<RecordDefinition>>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclInRecord";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclInRecord

struct DeclInObjcContainer : Predicate<std::tuple<Declaration, Fact<ObjcContainerDefinition>>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclInObjcContainer";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclInObjcContainer

struct DeclFamilyOf : Predicate<std::tuple<Declaration, Declaration>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclFamilyOf";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclFamilyOf

struct DeclFamily : Predicate<std::vector<Declaration>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclFamily";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclFamily

struct CxxToThrift : Predicate<std::tuple<XRefTarget, facebook::glean::cpp::schema::Fbthrift::Declaration>> {
  static const char* GLEAN_name() {
    return "cxx1.CxxToThrift";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct CxxToThrift

struct Attribute : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "cxx1.Attribute";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct Attribute

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::Access> {
  using Type = Enum<3>;
};


namespace schema {

namespace Cxx1 {

enum class Access { Public, Protected, Private };

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::RecordBase> {
  using Type = Tuple<facebook::glean::cpp::schema::Cxx1::RecordDeclaration, Repr<facebook::glean::cpp::schema::Cxx1::Access>, Bool>;
};


namespace schema {

namespace Cxx1 {

struct RecordBase {
  Fact<RecordDeclaration> base;
  Access access;
  bool isVirtual;

  bool operator==(const RecordBase& other) const {
    return std::tie(base,access,isVirtual)
             == std::tie(other.base,other.access,other.isVirtual);
  }
  bool operator!=(const RecordBase& other) const {
    return std::tie(base,access,isVirtual)
             != std::tie(other.base,other.access,other.isVirtual);
  }
  bool operator<(const RecordBase& other) const {
    return std::tie(base,access,isVirtual)
             < std::tie(other.base,other.access,other.isVirtual);
  }
  bool operator<=(const RecordBase& other) const {
    return std::tie(base,access,isVirtual)
             <= std::tie(other.base,other.access,other.isVirtual);
  }
  bool operator>(const RecordBase& other) const {
    return std::tie(base,access,isVirtual)
             > std::tie(other.base,other.access,other.isVirtual);
  }
  bool operator>=(const RecordBase& other) const {
    return std::tie(base,access,isVirtual)
             >= std::tie(other.base,other.access,other.isVirtual);
  }
  void outputRepr(Output<Repr<RecordBase>> out) const {
    outputValue(out, std::make_tuple(base, access, isVirtual));
  }
}; // struct RecordBase

struct RecordDefinition : Predicate<std::tuple<Fact<RecordDeclaration>, std::vector<RecordBase>, Fact<Declarations>>> {
  static const char* GLEAN_name() {
    return "cxx1.RecordDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct RecordDefinition

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::Variance> {
  using Type = Enum<3>;
};


namespace schema {

namespace Csharp {

enum class Variance { In, None_, Out };

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::UnityPackageType> {
  using Type = Enum<9>;
};


namespace schema {

namespace Csharp {

enum class UnityPackageType { Undefined, ThirdParty, Core, Runtime, Modules, Worlds, Apps, Clones, TestPackages };

struct UnityPackageToProject : Predicate<std::tuple<Fact<UnityPackage>, Fact<Project>>> {
  static const char* GLEAN_name() {
    return "csharp.UnityPackageToProject";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct UnityPackageToProject

struct UnityPackage : Predicate<std::tuple<UnityPackageType, std::string>> {
  static const char* GLEAN_name() {
    return "csharp.UnityPackage";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct UnityPackage

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::UnityAssemblyType> {
  using Type = Enum<7>;
};


namespace schema {

namespace Csharp {

enum class UnityAssemblyType { Package, Editor, Tests, TestsEditor, UnitTests, Internal, AllApis };

struct UnityProjectSource : Predicate<std::tuple<std::string, Fact<UnityPackage>, UnityAssemblyType, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "csharp.UnityProjectSource";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct UnityProjectSource

struct TypeParameter : Predicate<std::tuple<Fact<Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Variance>>, bool, bool, bool>> {
  static const char* GLEAN_name() {
    return "csharp.TypeParameter";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TypeParameter

struct SourceFileToProject : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Project>>> {
  static const char* GLEAN_name() {
    return "csharp.SourceFileToProject";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SourceFileToProject

struct SolutionToProject : Predicate<std::tuple<Fact<Solution>, Fact<Project>>> {
  static const char* GLEAN_name() {
    return "csharp.SolutionToProject";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SolutionToProject

struct Solution : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "csharp.Solution";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Solution

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::RefKind> {
  using Type = Enum<5>;
};


namespace schema {

namespace Csharp {

enum class RefKind { In, None_, Out, Ref, RefReadOnly };

struct ProjectToSourceFile : Predicate<std::tuple<Fact<Project>, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "csharp.ProjectToSourceFile";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ProjectToSourceFile

struct ProjectToSolution : Predicate<std::tuple<Fact<Project>, Fact<Solution>>> {
  static const char* GLEAN_name() {
    return "csharp.ProjectToSolution";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ProjectToSolution

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::ProjectSource> {
  using Type = Sum<facebook::glean::cpp::schema::Csharp::UnityProjectSource, facebook::glean::cpp::schema::Csharp::MSBuildProjectSource>;
};


namespace schema {

namespace Csharp {

struct ProjectSource {
  boost::variant<Alt<0, Fact<UnityProjectSource>>, Alt<1, Fact<MSBuildProjectSource>>> GLEAN_value;

  static ProjectSource unityProjectSource(const Fact<UnityProjectSource>& a) {
    return ProjectSource{Alt<0, Fact<UnityProjectSource>>(a)};
  }
  static ProjectSource msbuildProjectSource(const Fact<MSBuildProjectSource>& a) {
    return ProjectSource{Alt<1, Fact<MSBuildProjectSource>>(a)};
  }

  bool operator==(const ProjectSource& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const ProjectSource& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const ProjectSource& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const ProjectSource& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const ProjectSource& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const ProjectSource& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<ProjectSource>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct ProjectSource

struct Project : Predicate<std::tuple<ProjectSource, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>>> {
  static const char* GLEAN_name() {
    return "csharp.Project";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Project

struct Namespace : Predicate<std::tuple<Fact<Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Namespace>>>>> {
  static const char* GLEAN_name() {
    return "csharp.Namespace";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Namespace

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::NamedType> {
  using Type = Sum<facebook::glean::cpp::schema::Csharp::Class, facebook::glean::cpp::schema::Csharp::Interface, facebook::glean::cpp::schema::Csharp::Record, facebook::glean::cpp::schema::Csharp::Struct>;
};


namespace schema {

namespace Csharp {

struct NamedType {
  boost::variant<Alt<0, Fact<Class>>, Alt<1, Fact<Interface>>, Alt<2, Fact<Record>>, Alt<3, Fact<Struct>>> GLEAN_value;

  static NamedType class_(const Fact<Class>& a) {
    return NamedType{Alt<0, Fact<Class>>(a)};
  }
  static NamedType interface_(const Fact<Interface>& a) {
    return NamedType{Alt<1, Fact<Interface>>(a)};
  }
  static NamedType record_(const Fact<Record>& a) {
    return NamedType{Alt<2, Fact<Record>>(a)};
  }
  static NamedType struct_(const Fact<Struct>& a) {
    return NamedType{Alt<3, Fact<Struct>>(a)};
  }

  bool operator==(const NamedType& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const NamedType& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const NamedType& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const NamedType& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const NamedType& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const NamedType& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<NamedType>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct NamedType

struct NameLowerCase : Predicate<std::tuple<std::string, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "csharp.NameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct NameLowerCase

struct Name : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "csharp.Name";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Name

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::MethodKind> {
  using Type = Enum<21>;
};


namespace schema {

namespace Csharp {

enum class MethodKind { AnonymousFunction, BuiltinOperator, Constructor, Conversion, DeclareMethod, DelegateInvoke, Destructor, EventAdd, EventRaise, EventRemove, ExplicitInterfaceImplementation, FunctionPointerSignature, LambdaMethod, LocalFunction, Ordinary, PropertyGet, PropertySet, ReducedExtension, SharedConstructor, StaticConstructor, UserDefinedOperator };

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::MethodInvocationExpression> {
  using Type = Tuple<facebook::glean::cpp::schema::Csharp::MemberAccessLocation>;
};


namespace schema {

namespace Csharp {

struct MethodInvocationExpression {
  Fact<MemberAccessLocation> memberAccess;

  bool operator==(const MethodInvocationExpression& other) const {
    return std::tie(memberAccess)
             == std::tie(other.memberAccess);
  }
  bool operator!=(const MethodInvocationExpression& other) const {
    return std::tie(memberAccess)
             != std::tie(other.memberAccess);
  }
  bool operator<(const MethodInvocationExpression& other) const {
    return std::tie(memberAccess)
             < std::tie(other.memberAccess);
  }
  bool operator<=(const MethodInvocationExpression& other) const {
    return std::tie(memberAccess)
             <= std::tie(other.memberAccess);
  }
  bool operator>(const MethodInvocationExpression& other) const {
    return std::tie(memberAccess)
             > std::tie(other.memberAccess);
  }
  bool operator>=(const MethodInvocationExpression& other) const {
    return std::tie(memberAccess)
             >= std::tie(other.memberAccess);
  }
  void outputRepr(Output<Repr<MethodInvocationExpression>> out) const {
    outputValue(out, std::make_tuple(memberAccess));
  }
}; // struct MethodInvocationExpression

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::MemberAccessExpression> {
  using Type = Sum<facebook::glean::cpp::schema::Csharp::Local, facebook::glean::cpp::schema::Csharp::Parameter, facebook::glean::cpp::schema::Csharp::Field, facebook::glean::cpp::schema::Csharp::Property, facebook::glean::cpp::schema::Csharp::Method>;
};


namespace schema {

namespace Csharp {

struct MemberAccessExpression {
  boost::variant<Alt<0, Fact<Local>>, Alt<1, Fact<Parameter>>, Alt<2, Fact<Field>>, Alt<3, Fact<Property>>, Alt<4, Fact<Method>>> GLEAN_value;

  static MemberAccessExpression local(const Fact<Local>& a) {
    return MemberAccessExpression{Alt<0, Fact<Local>>(a)};
  }
  static MemberAccessExpression parameter(const Fact<Parameter>& a) {
    return MemberAccessExpression{Alt<1, Fact<Parameter>>(a)};
  }
  static MemberAccessExpression field(const Fact<Field>& a) {
    return MemberAccessExpression{Alt<2, Fact<Field>>(a)};
  }
  static MemberAccessExpression property(const Fact<Property>& a) {
    return MemberAccessExpression{Alt<3, Fact<Property>>(a)};
  }
  static MemberAccessExpression method(const Fact<Method>& a) {
    return MemberAccessExpression{Alt<4, Fact<Method>>(a)};
  }

  bool operator==(const MemberAccessExpression& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const MemberAccessExpression& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const MemberAccessExpression& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const MemberAccessExpression& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const MemberAccessExpression& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const MemberAccessExpression& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<MemberAccessExpression>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct MemberAccessExpression

struct MSBuildProjectSource : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "csharp.MSBuildProjectSource";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct MSBuildProjectSource

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::Location> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Src::FileLocation>, facebook::glean::cpp::schema::Src::FileLines>;
};


namespace schema {

namespace Csharp {

struct Location {
  facebook::glean::cpp::schema::Src::FileLocation fileLocation;
  Fact<facebook::glean::cpp::schema::Src::FileLines> fileLines;

  bool operator==(const Location& other) const {
    return std::tie(fileLocation,fileLines)
             == std::tie(other.fileLocation,other.fileLines);
  }
  bool operator!=(const Location& other) const {
    return std::tie(fileLocation,fileLines)
             != std::tie(other.fileLocation,other.fileLines);
  }
  bool operator<(const Location& other) const {
    return std::tie(fileLocation,fileLines)
             < std::tie(other.fileLocation,other.fileLines);
  }
  bool operator<=(const Location& other) const {
    return std::tie(fileLocation,fileLines)
             <= std::tie(other.fileLocation,other.fileLines);
  }
  bool operator>(const Location& other) const {
    return std::tie(fileLocation,fileLines)
             > std::tie(other.fileLocation,other.fileLines);
  }
  bool operator>=(const Location& other) const {
    return std::tie(fileLocation,fileLines)
             >= std::tie(other.fileLocation,other.fileLines);
  }
  void outputRepr(Output<Repr<Location>> out) const {
    outputValue(out, std::make_tuple(fileLocation, fileLines));
  }
}; // struct Location

struct MemberAccessLocation : Predicate<std::tuple<MemberAccessExpression, Location>> {
  static const char* GLEAN_name() {
    return "csharp.MemberAccessLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct MemberAccessLocation

struct MethodInvocationLocation : Predicate<std::tuple<Fact<Method>, Location, boost::variant<Alt<0, std::tuple<>>, Alt<1, MethodInvocationExpression>>>> {
  static const char* GLEAN_name() {
    return "csharp.MethodInvocationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct MethodInvocationLocation

struct Implements : Predicate<std::tuple<NamedType, Fact<Interface>>> {
  static const char* GLEAN_name() {
    return "csharp.Implements";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Implements

struct FunctionPointerType : Predicate<std::tuple<Fact<FullName>, Fact<Method>>> {
  static const char* GLEAN_name() {
    return "csharp.FunctionPointerType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FunctionPointerType

struct FullName : Predicate<std::tuple<Fact<Name>, Fact<Namespace>>> {
  static const char* GLEAN_name() {
    return "csharp.FullName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FullName

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::Accessibility> {
  using Type = Enum<10>;
};


namespace schema {

namespace Csharp {

enum class Accessibility { Friend, Internal, NotApplicable, Private, Protected, ProtectedAndFriend, ProtectedAndInternal, ProtectedOrFriend, ProtectedOrInternal, Public };

struct Class : Predicate<std::tuple<Fact<FullName>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Class>>>, std::vector<Fact<TypeParameter>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, NamedType>>, Accessibility, bool, bool, bool>> {
  static const char* GLEAN_name() {
    return "csharp.Class";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Class

struct Interface : Predicate<std::tuple<Fact<FullName>, std::vector<Fact<TypeParameter>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, NamedType>>, Accessibility, bool>> {
  static const char* GLEAN_name() {
    return "csharp.Interface";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Interface

struct Record : Predicate<std::tuple<Fact<FullName>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Record>>>, std::vector<Fact<TypeParameter>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, NamedType>>, Accessibility, bool, bool>> {
  static const char* GLEAN_name() {
    return "csharp.Record";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Record

struct Struct : Predicate<std::tuple<Fact<FullName>, std::vector<Fact<TypeParameter>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, NamedType>>, Accessibility>> {
  static const char* GLEAN_name() {
    return "csharp.Struct";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Struct

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::AType> {
  using Type = Sum<facebook::glean::cpp::schema::Csharp::ArrayType, Repr<facebook::glean::cpp::schema::Csharp::NamedType>, facebook::glean::cpp::schema::Csharp::FunctionPointerType, facebook::glean::cpp::schema::Csharp::PointerType, facebook::glean::cpp::schema::Csharp::TypeParameter>;
};


namespace schema {

namespace Csharp {

struct AType {
  boost::variant<Alt<0, Fact<ArrayType>>, Alt<1, NamedType>, Alt<2, Fact<FunctionPointerType>>, Alt<3, Fact<PointerType>>, Alt<4, Fact<TypeParameter>>> GLEAN_value;

  static AType arrayType(const Fact<ArrayType>& a) {
    return AType{Alt<0, Fact<ArrayType>>(a)};
  }
  static AType namedType(const NamedType& a) {
    return AType{Alt<1, NamedType>(a)};
  }
  static AType functionPointerType(const Fact<FunctionPointerType>& a) {
    return AType{Alt<2, Fact<FunctionPointerType>>(a)};
  }
  static AType pointerType(const Fact<PointerType>& a) {
    return AType{Alt<3, Fact<PointerType>>(a)};
  }
  static AType typeParameter(const Fact<TypeParameter>& a) {
    return AType{Alt<4, Fact<TypeParameter>>(a)};
  }

  bool operator==(const AType& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const AType& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const AType& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const AType& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const AType& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const AType& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<AType>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct AType

struct ArrayType : Predicate<std::tuple<AType, uint8_t>> {
  static const char* GLEAN_name() {
    return "csharp.ArrayType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ArrayType

} // namespace Csharp

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Csharp::Definition> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Csharp::AType>, facebook::glean::cpp::schema::Csharp::Method, facebook::glean::cpp::schema::Csharp::Field, facebook::glean::cpp::schema::Csharp::Parameter, facebook::glean::cpp::schema::Csharp::TypeParameter, facebook::glean::cpp::schema::Csharp::Local, facebook::glean::cpp::schema::Csharp::Property>;
};


namespace schema {

namespace Csharp {

struct Definition {
  boost::variant<Alt<0, AType>, Alt<1, Fact<Method>>, Alt<2, Fact<Field>>, Alt<3, Fact<Parameter>>, Alt<4, Fact<TypeParameter>>, Alt<5, Fact<Local>>, Alt<6, Fact<Property>>> GLEAN_value;

  static Definition type(const AType& a) {
    return Definition{Alt<0, AType>(a)};
  }
  static Definition method(const Fact<Method>& a) {
    return Definition{Alt<1, Fact<Method>>(a)};
  }
  static Definition field(const Fact<Field>& a) {
    return Definition{Alt<2, Fact<Field>>(a)};
  }
  static Definition parameter(const Fact<Parameter>& a) {
    return Definition{Alt<3, Fact<Parameter>>(a)};
  }
  static Definition typeParameter(const Fact<TypeParameter>& a) {
    return Definition{Alt<4, Fact<TypeParameter>>(a)};
  }
  static Definition local(const Fact<Local>& a) {
    return Definition{Alt<5, Fact<Local>>(a)};
  }
  static Definition property(const Fact<Property>& a) {
    return Definition{Alt<6, Fact<Property>>(a)};
  }

  bool operator==(const Definition& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Definition& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Definition& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Definition& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Definition& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Definition& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Definition>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Definition

struct DefinitionLocation : Predicate<std::tuple<Definition, Location>> {
  static const char* GLEAN_name() {
    return "csharp.DefinitionLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DefinitionLocation

struct DefinitionLocationName : Predicate<std::tuple<Definition, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, std::string>> {
  static const char* GLEAN_name() {
    return "csharp.DefinitionLocationName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DefinitionLocationName

struct FileDefinitions : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Definition>> {
  static const char* GLEAN_name() {
    return "csharp.FileDefinitions";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileDefinitions

struct FileEntityXRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, Definition>> {
  static const char* GLEAN_name() {
    return "csharp.FileEntityXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileEntityXRefs

struct SearchByName : Predicate<std::tuple<Fact<Name>, Definition>> {
  static const char* GLEAN_name() {
    return "csharp.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchByName

struct Field : Predicate<std::tuple<Fact<Name>, AType, NamedType, Accessibility, bool, bool, bool>> {
  static const char* GLEAN_name() {
    return "csharp.Field";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Field

struct Local : Predicate<std::tuple<Fact<Name>, AType, Fact<Method>, RefKind, bool>> {
  static const char* GLEAN_name() {
    return "csharp.Local";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Local

struct Method : Predicate<std::tuple<Fact<Name>, NamedType, std::vector<Fact<TypeParameter>>, std::vector<Fact<Parameter>>, bool, AType, Accessibility>> {
  static const char* GLEAN_name() {
    return "csharp.Method";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Method

struct ObjectCreationLocation : Predicate<std::tuple<AType, Fact<Method>, Location>> {
  static const char* GLEAN_name() {
    return "csharp.ObjectCreationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ObjectCreationLocation

struct Parameter : Predicate<std::tuple<Fact<Name>, AType, RefKind, bool, bool, bool>> {
  static const char* GLEAN_name() {
    return "csharp.Parameter";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Parameter

struct PointerType : Predicate<std::tuple<AType>> {
  static const char* GLEAN_name() {
    return "csharp.PointerType";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct PointerType

struct Property : Predicate<std::tuple<Fact<Name>, NamedType, AType, std::vector<Fact<Parameter>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Method>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Method>>>, bool, bool>> {
  static const char* GLEAN_name() {
    return "csharp.Property";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Property

struct TypeLocation : Predicate<std::tuple<AType, Location>> {
  static const char* GLEAN_name() {
    return "csharp.TypeLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TypeLocation

} // namespace Csharp

namespace Codemarkup {

namespace Yaml {

struct YamlDataAvailable : Predicate<Fact<facebook::glean::cpp::schema::Src::File>> {
  static const char* GLEAN_name() {
    return "codemarkup.yaml.YamlDataAvailable";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct YamlDataAvailable

} // namespace Yaml

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::Types::Visibility> {
  using Type = Enum<4>;
};


namespace schema {

namespace Codemarkup {

namespace Types {

enum class Visibility { Public, Protected, Private, Internal };

} // namespace Types

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind> {
  using Type = Enum<34>;
};


namespace schema {

namespace Codemarkup {

namespace Types {

enum class SymbolKind { Package, Type, Value, File, Module, Namespace, Class_, Method, Property, Field, Constructor, Enum_, Interface, Function, Variable, Constant, String, Number, Boolean, Array_, Object_, Key, Null, Enumerator, Struct, Event, Operator, TypeParameter, Union, Macro, Trait, Fragment, Operation, Directive };

} // namespace Types

} // namespace Codemarkup

namespace Search {

namespace Code {

struct CxxNameLowerCase : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, std::string>> {
  static const char* GLEAN_name() {
    return "search.code.CxxNameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct CxxNameLowerCase

struct FlowNameLowerCase : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, std::string>> {
  static const char* GLEAN_name() {
    return "search.code.FlowNameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct FlowNameLowerCase

struct HackNameLowerCase : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, std::string>> {
  static const char* GLEAN_name() {
    return "search.code.HackNameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct HackNameLowerCase

struct PythonNameLowerCase : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, std::string>> {
  static const char* GLEAN_name() {
    return "search.code.PythonNameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct PythonNameLowerCase

} // namespace Code

} // namespace Search

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>, Bool>;
};


namespace schema {

namespace Codemarkup {

namespace Types {

struct SymbolInfo {
  SymbolKind kind;
  bool isAbstract;

  bool operator==(const SymbolInfo& other) const {
    return std::tie(kind,isAbstract)
             == std::tie(other.kind,other.isAbstract);
  }
  bool operator!=(const SymbolInfo& other) const {
    return std::tie(kind,isAbstract)
             != std::tie(other.kind,other.isAbstract);
  }
  bool operator<(const SymbolInfo& other) const {
    return std::tie(kind,isAbstract)
             < std::tie(other.kind,other.isAbstract);
  }
  bool operator<=(const SymbolInfo& other) const {
    return std::tie(kind,isAbstract)
             <= std::tie(other.kind,other.isAbstract);
  }
  bool operator>(const SymbolInfo& other) const {
    return std::tie(kind,isAbstract)
             > std::tie(other.kind,other.isAbstract);
  }
  bool operator>=(const SymbolInfo& other) const {
    return std::tie(kind,isAbstract)
             >= std::tie(other.kind,other.isAbstract);
  }
  void outputRepr(Output<Repr<SymbolInfo>> out) const {
    outputValue(out, std::make_tuple(kind, isAbstract));
  }
}; // struct SymbolInfo

} // namespace Types

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Src::ByteSpan>, Repr<facebook::glean::cpp::schema::Src::Range>>;
};


namespace schema {

namespace Codemarkup {

namespace Types {

struct RangeSpan {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Src::ByteSpan>, Alt<1, facebook::glean::cpp::schema::Src::Range>> GLEAN_value;

  static RangeSpan span(const facebook::glean::cpp::schema::Src::ByteSpan& a) {
    return RangeSpan{Alt<0, facebook::glean::cpp::schema::Src::ByteSpan>(a)};
  }
  static RangeSpan range(const facebook::glean::cpp::schema::Src::Range& a) {
    return RangeSpan{Alt<1, facebook::glean::cpp::schema::Src::Range>(a)};
  }

  bool operator==(const RangeSpan& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const RangeSpan& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const RangeSpan& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const RangeSpan& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const RangeSpan& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const RangeSpan& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<RangeSpan>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct RangeSpan

struct RangeSpanContains : Predicate<std::tuple<RangeSpan, RangeSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.types.RangeSpanContains";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct RangeSpanContains

} // namespace Types

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::Types::Modifiers> {
  using Type = Tuple<Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool>;
};


namespace schema {

namespace Codemarkup {

namespace Types {

struct Modifiers {
  bool isAbstract;
  bool isFinal;
  bool isAsync;
  bool isStatic;
  bool isReadonly;
  bool isConst;
  bool isMutable;
  bool isVolatile;
  bool isVirtual;
  bool isInline;

  bool operator==(const Modifiers& other) const {
    return std::tie(isAbstract,isFinal,isAsync,isStatic,isReadonly,isConst,isMutable,isVolatile,isVirtual,isInline)
             == std::tie(other.isAbstract,other.isFinal,other.isAsync,other.isStatic,other.isReadonly,other.isConst,other.isMutable,other.isVolatile,other.isVirtual,other.isInline);
  }
  bool operator!=(const Modifiers& other) const {
    return std::tie(isAbstract,isFinal,isAsync,isStatic,isReadonly,isConst,isMutable,isVolatile,isVirtual,isInline)
             != std::tie(other.isAbstract,other.isFinal,other.isAsync,other.isStatic,other.isReadonly,other.isConst,other.isMutable,other.isVolatile,other.isVirtual,other.isInline);
  }
  bool operator<(const Modifiers& other) const {
    return std::tie(isAbstract,isFinal,isAsync,isStatic,isReadonly,isConst,isMutable,isVolatile,isVirtual,isInline)
             < std::tie(other.isAbstract,other.isFinal,other.isAsync,other.isStatic,other.isReadonly,other.isConst,other.isMutable,other.isVolatile,other.isVirtual,other.isInline);
  }
  bool operator<=(const Modifiers& other) const {
    return std::tie(isAbstract,isFinal,isAsync,isStatic,isReadonly,isConst,isMutable,isVolatile,isVirtual,isInline)
             <= std::tie(other.isAbstract,other.isFinal,other.isAsync,other.isStatic,other.isReadonly,other.isConst,other.isMutable,other.isVolatile,other.isVirtual,other.isInline);
  }
  bool operator>(const Modifiers& other) const {
    return std::tie(isAbstract,isFinal,isAsync,isStatic,isReadonly,isConst,isMutable,isVolatile,isVirtual,isInline)
             > std::tie(other.isAbstract,other.isFinal,other.isAsync,other.isStatic,other.isReadonly,other.isConst,other.isMutable,other.isVolatile,other.isVirtual,other.isInline);
  }
  bool operator>=(const Modifiers& other) const {
    return std::tie(isAbstract,isFinal,isAsync,isStatic,isReadonly,isConst,isMutable,isVolatile,isVirtual,isInline)
             >= std::tie(other.isAbstract,other.isFinal,other.isAsync,other.isStatic,other.isReadonly,other.isConst,other.isMutable,other.isVolatile,other.isVirtual,other.isInline);
  }
  void outputRepr(Output<Repr<Modifiers>> out) const {
    outputValue(out, std::make_tuple(isAbstract, isFinal, isAsync, isStatic, isReadonly, isConst, isMutable, isVolatile, isVirtual, isInline));
  }
}; // struct Modifiers

} // namespace Types

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::Types::Modifier> {
  using Type = Enum<10>;
};


namespace schema {

namespace Codemarkup {

namespace Types {

enum class Modifier { Abstract, Final, Async, Static, Readonly, Const, Mutable, Volatile, Virtual, Inline };

} // namespace Types

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::Types::Location> {
  using Type = Tuple<String, facebook::glean::cpp::schema::Src::File, Repr<facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan>, Maybe<Repr<facebook::glean::cpp::schema::Src::FileLocation>>>;
};


namespace schema {

namespace Codemarkup {

namespace Types {

struct Location {
  std::string name;
  Fact<facebook::glean::cpp::schema::Src::File> file;
  RangeSpan location;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Src::FileLocation>> destination;

  bool operator==(const Location& other) const {
    return std::tie(name,file,location,destination)
             == std::tie(other.name,other.file,other.location,other.destination);
  }
  bool operator!=(const Location& other) const {
    return std::tie(name,file,location,destination)
             != std::tie(other.name,other.file,other.location,other.destination);
  }
  bool operator<(const Location& other) const {
    return std::tie(name,file,location,destination)
             < std::tie(other.name,other.file,other.location,other.destination);
  }
  bool operator<=(const Location& other) const {
    return std::tie(name,file,location,destination)
             <= std::tie(other.name,other.file,other.location,other.destination);
  }
  bool operator>(const Location& other) const {
    return std::tie(name,file,location,destination)
             > std::tie(other.name,other.file,other.location,other.destination);
  }
  bool operator>=(const Location& other) const {
    return std::tie(name,file,location,destination)
             >= std::tie(other.name,other.file,other.location,other.destination);
  }
  void outputRepr(Output<Repr<Location>> out) const {
    outputValue(out, std::make_tuple(name, file, location, destination));
  }
}; // struct Location

} // namespace Types

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Codemarkup::Types::Location>, Repr<facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan>>;
};


namespace schema {

namespace Codemarkup {

namespace Types {

struct XRefLocation {
  Location target;
  RangeSpan source;

  bool operator==(const XRefLocation& other) const {
    return std::tie(target,source)
             == std::tie(other.target,other.source);
  }
  bool operator!=(const XRefLocation& other) const {
    return std::tie(target,source)
             != std::tie(other.target,other.source);
  }
  bool operator<(const XRefLocation& other) const {
    return std::tie(target,source)
             < std::tie(other.target,other.source);
  }
  bool operator<=(const XRefLocation& other) const {
    return std::tie(target,source)
             <= std::tie(other.target,other.source);
  }
  bool operator>(const XRefLocation& other) const {
    return std::tie(target,source)
             > std::tie(other.target,other.source);
  }
  bool operator>=(const XRefLocation& other) const {
    return std::tie(target,source)
             >= std::tie(other.target,other.source);
  }
  void outputRepr(Output<Repr<XRefLocation>> out) const {
    outputValue(out, std::make_tuple(target, source));
  }
}; // struct XRefLocation

} // namespace Types

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::Search::SearchCase> {
  using Type = Enum<2>;
};


namespace schema {

namespace Codemarkup {

namespace Search {

enum class SearchCase { Sensitive, Insensitive };

} // namespace Search

namespace Scip {

struct LsifKindToKind : Predicate<std::tuple<facebook::glean::cpp::schema::Lsif::Types::SymbolKind, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.scip.LsifKindToKind";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LsifKindToKind

struct FileXLangSymbolRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan, Fact<facebook::glean::cpp::schema::Scip::Symbol>>> {
  static const char* GLEAN_name() {
    return "codemarkup.scip.FileXLangSymbolRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileXLangSymbolRefs

} // namespace Scip

namespace Python {

struct NonImportPythonDeclarationKind : Predicate<std::tuple<facebook::glean::cpp::schema::Python::Declaration, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.NonImportPythonDeclarationKind";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct NonImportPythonDeclarationKind

struct NonImportPythonDeclarationInfo : Predicate<std::tuple<facebook::glean::cpp::schema::Python::Declaration, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.NonImportPythonDeclarationInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct NonImportPythonDeclarationInfo

struct ConvertLabel : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Python::Name>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.ConvertLabel";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ConvertLabel

} // namespace Python

namespace Pp {

struct PpIncludeXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::PPTrace>, facebook::glean::cpp::schema::Src::Range, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "codemarkup.pp.PpIncludeXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct PpIncludeXRefLocations

} // namespace Pp

namespace Lsif {

struct LsifKindToKind : Predicate<std::tuple<facebook::glean::cpp::schema::Lsif::Types::SymbolKind, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.lsif.LsifKindToKind";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct LsifKindToKind

} // namespace Lsif

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::Hack::RequiredRelation> {
  using Type = Enum<3>;
};


namespace schema {

namespace Codemarkup {

namespace Hack {

enum class RequiredRelation { implements_, extends_, class_ };

struct HackInheritedEntities : Predicate<std::tuple<facebook::glean::cpp::schema::Hack::ContainerDeclaration, facebook::glean::cpp::schema::Hack::Declaration>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackInheritedEntities";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackInheritedEntities

struct HackEnumInheritedMembers : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Hack::MethodDeclaration>>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackEnumInheritedMembers";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackEnumInheritedMembers

struct FromHackVisibility : Predicate<std::tuple<facebook::glean::cpp::schema::Hack::Visibility, facebook::glean::cpp::schema::Codemarkup::Types::Visibility>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.FromHackVisibility";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FromHackVisibility

} // namespace Hack

namespace Flow {

struct FlowDocumentationSpan : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Flow::Documentation>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowDocumentationSpan";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowDocumentationSpan

struct FlowDeclarationDocumentation : Predicate<std::tuple<facebook::glean::cpp::schema::Flow::SomeDeclaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowDeclarationDocumentation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowDeclarationDocumentation

} // namespace Flow

namespace Cxx {

struct FromCxxVisibility : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Access, facebook::glean::cpp::schema::Codemarkup::Types::Visibility>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.FromCxxVisibility";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FromCxxVisibility

struct CxxFileEntityXMapVariableXRefDeclLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::FileXRefs>, facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxFileEntityXMapVariableXRefDeclLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxFileEntityXMapVariableXRefDeclLocations

struct CxxDeclarationModifiers : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Codemarkup::Types::Modifiers>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDeclarationModifiers";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDeclarationModifiers

struct CxxDeclVisibility : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Codemarkup::Types::Visibility>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDeclVisibility";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDeclVisibility

struct CxxDeclKind : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDeclKind";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDeclKind

struct CxxDeclInfo : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDeclInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDeclInfo

struct CxxDataAvailable : Predicate<Fact<facebook::glean::cpp::schema::Src::File>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDataAvailable";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDataAvailable

} // namespace Cxx

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::SearchStyle> {
  using Type = Enum<2>;
};


namespace schema {

namespace Codemarkup {

enum class SearchStyle { ShowAll, HideUninteresting };

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::RelationType> {
  using Type = Enum<7>;
};


namespace schema {

namespace Codemarkup {

enum class RelationType { ExtendsParentOfChild, ExtendsChildOfParent, ContainsChildOfParent, ContainsParentOfChild, RequireExtendsParentOfChild, RequireImplementsParentOfChild, RequireClassParentOfChild };

struct IndexedFile : Predicate<Fact<facebook::glean::cpp::schema::Src::File>> {
  static const char* GLEAN_name() {
    return "codemarkup.IndexedFile";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct IndexedFile

struct EntityDataAvailable : Predicate<Fact<facebook::glean::cpp::schema::Src::File>> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityDataAvailable";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityDataAvailable

} // namespace Codemarkup

namespace Code {

namespace Scip {

using SymbolId = Fact<facebook::glean::cpp::schema::Scip::Symbol>;

} // namespace Scip

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Scip::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Scip::SomeEntity>, Repr<facebook::glean::cpp::schema::Scip::SomeEntity>, Repr<facebook::glean::cpp::schema::Scip::SomeEntity>, Repr<facebook::glean::cpp::schema::Scip::SomeEntity>, Repr<facebook::glean::cpp::schema::Scip::SomeEntity>, Repr<facebook::glean::cpp::schema::Scip::SomeEntity>>;
};


namespace schema {

namespace Code {

namespace Scip {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Scip::SomeEntity>, Alt<1, facebook::glean::cpp::schema::Scip::SomeEntity>, Alt<2, facebook::glean::cpp::schema::Scip::SomeEntity>, Alt<3, facebook::glean::cpp::schema::Scip::SomeEntity>, Alt<4, facebook::glean::cpp::schema::Scip::SomeEntity>, Alt<5, facebook::glean::cpp::schema::Scip::SomeEntity>> GLEAN_value;

  static Entity rust(const facebook::glean::cpp::schema::Scip::SomeEntity& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Scip::SomeEntity>(a)};
  }
  static Entity go(const facebook::glean::cpp::schema::Scip::SomeEntity& a) {
    return Entity{Alt<1, facebook::glean::cpp::schema::Scip::SomeEntity>(a)};
  }
  static Entity typescript(const facebook::glean::cpp::schema::Scip::SomeEntity& a) {
    return Entity{Alt<2, facebook::glean::cpp::schema::Scip::SomeEntity>(a)};
  }
  static Entity java(const facebook::glean::cpp::schema::Scip::SomeEntity& a) {
    return Entity{Alt<3, facebook::glean::cpp::schema::Scip::SomeEntity>(a)};
  }
  static Entity kotlin(const facebook::glean::cpp::schema::Scip::SomeEntity& a) {
    return Entity{Alt<4, facebook::glean::cpp::schema::Scip::SomeEntity>(a)};
  }
  static Entity swift(const facebook::glean::cpp::schema::Scip::SomeEntity& a) {
    return Entity{Alt<5, facebook::glean::cpp::schema::Scip::SomeEntity>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Scip

} // namespace Code

namespace Codemarkup {

namespace Scip {

struct EntityInfo : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Scip::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.scip.EntityInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EntityInfo

struct ScipEntityDocumentation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Scip::Entity, Fact<facebook::glean::cpp::schema::Scip::Documentation>>> {
  static const char* GLEAN_name() {
    return "codemarkup.scip.ScipEntityDocumentation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ScipEntityDocumentation

struct ScipEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Scip::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.scip.ScipEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ScipEntityLocation

struct ScipEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Scip::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "codemarkup.scip.ScipEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ScipEntityUses

struct ScipFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Scip::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.scip.ScipFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ScipFileEntityXRefLocations

struct ScipResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Scip::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.scip.ScipResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ScipResolveLocation

} // namespace Scip

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Python::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Python::Declaration>>;
};


namespace schema {

namespace Code {

namespace Python {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Python::Declaration>> GLEAN_value;

  static Entity decl(const facebook::glean::cpp::schema::Python::Declaration& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Python::Declaration>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Python

} // namespace Code

namespace Codemarkup {

namespace Python {

struct PythonContainsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, facebook::glean::cpp::schema::Code::Python::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonContainsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonContainsChildEntity

struct PythonContainsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, facebook::glean::cpp::schema::Code::Python::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonContainsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonContainsParentEntity

struct PythonEntityComments : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonEntityComments";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonEntityComments

struct PythonEntityInfo : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonEntityInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonEntityInfo

struct PythonEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonEntityKind

struct PythonEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonEntityLocation

struct PythonEntityModuleName : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, std::string>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonEntityModuleName";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonEntityModuleName

struct PythonEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonEntityUses

struct PythonExtendsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, facebook::glean::cpp::schema::Code::Python::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonExtendsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonExtendsChildEntity

struct PythonExtendsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, facebook::glean::cpp::schema::Code::Python::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonExtendsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonExtendsParentEntity

struct PythonFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Python::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonFileEntityXRefLocations

struct PythonModifiers : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Modifiers>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonModifiers";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonModifiers

struct PythonResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Python::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonResolveLocation

struct PythonVisibility : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Visibility>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonVisibility";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonVisibility

} // namespace Python

} // namespace Codemarkup

namespace Code {

namespace Python {

using CallArgument = facebook::glean::cpp::schema::Python::CallArgument;

} // namespace Python

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Python::Annotations> {
  using Type = Sum<Array<Repr<facebook::glean::cpp::schema::Python::Decorator>>>;
};


namespace schema {

namespace Code {

namespace Python {

struct Annotations {
  boost::variant<Alt<0, std::vector<facebook::glean::cpp::schema::Python::Decorator>>> GLEAN_value;

  static Annotations decorators(const std::vector<facebook::glean::cpp::schema::Python::Decorator>& a) {
    return Annotations{Alt<0, std::vector<facebook::glean::cpp::schema::Python::Decorator>>(a)};
  }

  bool operator==(const Annotations& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Annotations& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Annotations& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Annotations>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Annotations

} // namespace Python

} // namespace Code

namespace Codemarkup {

namespace Python {

struct PythonAnnotation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Python::Entity, facebook::glean::cpp::schema::Code::Python::Annotations>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonAnnotation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonAnnotation

} // namespace Python

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Pp::Entity> {
  using Type = Sum<facebook::glean::cpp::schema::Pp1::Define, facebook::glean::cpp::schema::Pp1::Undef, facebook::glean::cpp::schema::Src::File>;
};


namespace schema {

namespace Code {

namespace Pp {

struct Entity {
  boost::variant<Alt<0, Fact<facebook::glean::cpp::schema::Pp1::Define>>, Alt<1, Fact<facebook::glean::cpp::schema::Pp1::Undef>>, Alt<2, Fact<facebook::glean::cpp::schema::Src::File>>> GLEAN_value;

  static Entity define(const Fact<facebook::glean::cpp::schema::Pp1::Define>& a) {
    return Entity{Alt<0, Fact<facebook::glean::cpp::schema::Pp1::Define>>(a)};
  }
  static Entity undef(const Fact<facebook::glean::cpp::schema::Pp1::Undef>& a) {
    return Entity{Alt<1, Fact<facebook::glean::cpp::schema::Pp1::Undef>>(a)};
  }
  static Entity include_(const Fact<facebook::glean::cpp::schema::Src::File>& a) {
    return Entity{Alt<2, Fact<facebook::glean::cpp::schema::Src::File>>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Pp

} // namespace Code

namespace Codemarkup {

namespace Pp {

struct PPEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Pp::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.pp.PPEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct PPEntityLocation

struct PpEntityInfo : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Pp::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.pp.PpEntityInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct PpEntityInfo

struct PpEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Pp::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.pp.PpEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct PpEntityKind

struct PpEntityTraceXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::Trace>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Pp::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.pp.PpEntityTraceXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct PpEntityTraceXRefLocations

struct PpEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Pp::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.pp.PpEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct PpEntityUses

struct PpFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Pp::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.pp.PpFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct PpFileEntityXRefLocations

struct PpResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Pp::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.pp.PpResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct PpResolveLocation

struct PpResolveTraceLocation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::Trace>, facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Pp::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.pp.PpResolveTraceLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct PpResolveTraceLocation

} // namespace Pp

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Lsif::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>, Repr<facebook::glean::cpp::schema::Lsif::SomeEntity>>;
};


namespace schema {

namespace Code {

namespace Lsif {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Lsif::SomeEntity>, Alt<1, facebook::glean::cpp::schema::Lsif::SomeEntity>, Alt<2, facebook::glean::cpp::schema::Lsif::SomeEntity>, Alt<3, facebook::glean::cpp::schema::Lsif::SomeEntity>, Alt<4, facebook::glean::cpp::schema::Lsif::SomeEntity>, Alt<5, facebook::glean::cpp::schema::Lsif::SomeEntity>, Alt<6, facebook::glean::cpp::schema::Lsif::SomeEntity>, Alt<7, facebook::glean::cpp::schema::Lsif::SomeEntity>, Alt<8, facebook::glean::cpp::schema::Lsif::SomeEntity>, Alt<9, facebook::glean::cpp::schema::Lsif::SomeEntity>, Alt<10, facebook::glean::cpp::schema::Lsif::SomeEntity>, Alt<11, facebook::glean::cpp::schema::Lsif::SomeEntity>> GLEAN_value;

  static Entity erlang(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }
  static Entity fsharp(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<1, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }
  static Entity go(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<2, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }
  static Entity haskell(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<3, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }
  static Entity java(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<4, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }
  static Entity kotlin(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<5, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }
  static Entity ocaml(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<6, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }
  static Entity python(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<7, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }
  static Entity rust(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<8, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }
  static Entity scala(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<9, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }
  static Entity swift(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<10, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }
  static Entity typescript(const facebook::glean::cpp::schema::Lsif::SomeEntity& a) {
    return Entity{Alt<11, facebook::glean::cpp::schema::Lsif::SomeEntity>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Lsif

} // namespace Code

namespace Codemarkup {

namespace Lsif {

struct EntityInfo : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Lsif::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.lsif.EntityInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct EntityInfo

struct LsifEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Lsif::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.lsif.LsifEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct LsifEntityLocation

struct LsifEntityModuleName : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Lsif::Entity, std::string>> {
  static const char* GLEAN_name() {
    return "codemarkup.lsif.LsifEntityModuleName";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct LsifEntityModuleName

struct LsifEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Lsif::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "codemarkup.lsif.LsifEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct LsifEntityUses

struct LsifFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Lsif::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.lsif.LsifFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct LsifFileEntityXRefLocations

struct LsifResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Lsif::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.lsif.LsifResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 3;
  }
}; // struct LsifResolveLocation

} // namespace Lsif

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Kotlin::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Kotlin::Alpha::Declaration>>;
};


namespace schema {

namespace Code {

namespace Kotlin {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Kotlin::Alpha::Declaration>> GLEAN_value;

  static Entity decl(const facebook::glean::cpp::schema::Kotlin::Alpha::Declaration& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Kotlin::Alpha::Declaration>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Kotlin

} // namespace Code

namespace Codemarkup {

namespace Kotlin {

struct KotlinContainsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Kotlin::Entity, facebook::glean::cpp::schema::Code::Kotlin::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.kotlin.KotlinContainsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct KotlinContainsChildEntity

struct KotlinContainsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Kotlin::Entity, facebook::glean::cpp::schema::Code::Kotlin::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.kotlin.KotlinContainsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct KotlinContainsParentEntity

struct KotlinEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Kotlin::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.kotlin.KotlinEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct KotlinEntityKind

struct KotlinEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Kotlin::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.kotlin.KotlinEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct KotlinEntityLocation

struct KotlinEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Kotlin::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.kotlin.KotlinEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct KotlinEntityUses

struct KotlinExtendsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Kotlin::Entity, facebook::glean::cpp::schema::Code::Kotlin::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.kotlin.KotlinExtendsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct KotlinExtendsParentEntity

struct KotlinFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Kotlin::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.kotlin.KotlinFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct KotlinFileEntityXRefLocations

struct KotlinResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Kotlin::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.kotlin.KotlinResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct KotlinResolveLocation

} // namespace Kotlin

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Java::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Java::Alpha::Declaration>>;
};


namespace schema {

namespace Code {

namespace Java {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Java::Alpha::Declaration>> GLEAN_value;

  static Entity decl(const facebook::glean::cpp::schema::Java::Alpha::Declaration& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Java::Alpha::Declaration>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Java

} // namespace Code

namespace Codemarkup {

namespace Java {

struct JavaContainsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Java::Entity, facebook::glean::cpp::schema::Code::Java::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaContainsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaContainsChildEntity

struct JavaContainsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Java::Entity, facebook::glean::cpp::schema::Code::Java::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaContainsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaContainsParentEntity

struct JavaEntityDocumentation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Java::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaEntityDocumentation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaEntityDocumentation

struct JavaEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Java::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaEntityKind

struct JavaEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Java::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaEntityLocation

struct JavaEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Java::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaEntityUses

struct JavaExtendsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Java::Entity, facebook::glean::cpp::schema::Code::Java::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaExtendsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaExtendsChildEntity

struct JavaExtendsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Java::Entity, facebook::glean::cpp::schema::Code::Java::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaExtendsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaExtendsParentEntity

struct JavaModifiers : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Java::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Modifiers>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaModifiers";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaModifiers

struct JavaResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Java::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaResolveLocation

struct JavaVisibility : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Java::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Visibility>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaVisibility";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaVisibility

struct JavalFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Java::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavalFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavalFileEntityXRefLocations

} // namespace Java

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Java::Annotations> {
  using Type = Sum<Array<facebook::glean::cpp::schema::Java::Alpha::Annotation>>;
};


namespace schema {

namespace Code {

namespace Java {

struct Annotations {
  boost::variant<Alt<0, std::vector<Fact<facebook::glean::cpp::schema::Java::Alpha::Annotation>>>> GLEAN_value;

  static Annotations annotations(const std::vector<Fact<facebook::glean::cpp::schema::Java::Alpha::Annotation>>& a) {
    return Annotations{Alt<0, std::vector<Fact<facebook::glean::cpp::schema::Java::Alpha::Annotation>>>(a)};
  }

  bool operator==(const Annotations& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Annotations& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Annotations& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Annotations>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Annotations

} // namespace Java

} // namespace Code

namespace Codemarkup {

namespace Java {

struct JavaAnnotation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Java::Entity, facebook::glean::cpp::schema::Code::Java::Annotations>> {
  static const char* GLEAN_name() {
    return "codemarkup.java.JavaAnnotation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct JavaAnnotation

} // namespace Java

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Hs::Entity> {
  using Type = Sum<facebook::glean::cpp::schema::Hs::Name, facebook::glean::cpp::schema::Hs::Module>;
};


namespace schema {

namespace Code {

namespace Hs {

struct Entity {
  boost::variant<Alt<0, Fact<facebook::glean::cpp::schema::Hs::Name>>, Alt<1, Fact<facebook::glean::cpp::schema::Hs::Module>>> GLEAN_value;

  static Entity name(const Fact<facebook::glean::cpp::schema::Hs::Name>& a) {
    return Entity{Alt<0, Fact<facebook::glean::cpp::schema::Hs::Name>>(a)};
  }
  static Entity mod(const Fact<facebook::glean::cpp::schema::Hs::Module>& a) {
    return Entity{Alt<1, Fact<facebook::glean::cpp::schema::Hs::Module>>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Hs

} // namespace Code

namespace Codemarkup {

namespace Haskell {

struct HaskellContainsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hs::Entity, facebook::glean::cpp::schema::Code::Hs::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.haskell.HaskellContainsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HaskellContainsChildEntity

struct HaskellContainsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hs::Entity, facebook::glean::cpp::schema::Code::Hs::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.haskell.HaskellContainsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HaskellContainsParentEntity

struct HaskellEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hs::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.haskell.HaskellEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HaskellEntityLocation

struct HaskellEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hs::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.haskell.HaskellEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HaskellEntityUses

struct HaskellFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Hs::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.haskell.HaskellFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HaskellFileEntityXRefLocations

struct HaskellResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Hs::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.haskell.HaskellResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HaskellResolveLocation

} // namespace Haskell

} // namespace Codemarkup

namespace Search {

namespace Hs {

struct SearchByLowerCaseName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Hs::Entity>> {
  static const char* GLEAN_name() {
    return "search.hs.SearchByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 9;
  }
}; // struct SearchByLowerCaseName

struct SearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Hs::Entity>> {
  static const char* GLEAN_name() {
    return "search.hs.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 9;
  }
}; // struct SearchByName

} // namespace Hs

} // namespace Search

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Hack::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Hack::Declaration>>;
};


namespace schema {

namespace Code {

namespace Hack {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Hack::Declaration>> GLEAN_value;

  static Entity decl(const facebook::glean::cpp::schema::Hack::Declaration& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Hack::Declaration>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Hack

} // namespace Code

namespace Codemarkup {

namespace Hack {

struct EntityHasHideFromDocsAttr : Predicate<facebook::glean::cpp::schema::Code::Hack::Entity> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.EntityHasHideFromDocsAttr";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct EntityHasHideFromDocsAttr

struct HackContainsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Code::Hack::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackContainsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackContainsChildEntity

struct HackContainsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Code::Hack::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackContainsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackContainsParentEntity

struct HackEntityDocumentation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackEntityDocumentation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackEntityDocumentation

struct HackEntityInfo : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackEntityInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackEntityInfo

struct HackEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackEntityKind

struct HackEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackEntityLocation

struct HackEntityModuleName : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, std::string>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackEntityModuleName";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackEntityModuleName

struct HackEntitySource : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Code::Hack::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackEntitySource";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackEntitySource

struct HackEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackEntityUses

struct HackExtendsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Code::Hack::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackExtendsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackExtendsChildEntity

struct HackExtendsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Code::Hack::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackExtendsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackExtendsParentEntity

struct HackExtendsParentEntityConcise : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Code::Hack::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackExtendsParentEntityConcise";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackExtendsParentEntityConcise

struct HackFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Hack::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackFileEntityXRefLocations

struct HackFileEntityXRefSpans : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, facebook::glean::cpp::schema::Code::Hack::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackFileEntityXRefSpans";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackFileEntityXRefSpans

struct HackModifiers : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Modifiers>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackModifiers";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackModifiers

struct HackRequiredConstraint : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, RequiredRelation, facebook::glean::cpp::schema::Code::Hack::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackRequiredConstraint";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackRequiredConstraint

struct HackResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Hack::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackResolveLocation

struct HackVisibility : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Visibility>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackVisibility";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackVisibility

} // namespace Hack

} // namespace Codemarkup

namespace Code {

namespace Hack {

using CallArgument = facebook::glean::cpp::schema::Hack::CallArgument;

} // namespace Hack

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Hack::Annotations> {
  using Type = Sum<Array<facebook::glean::cpp::schema::Hack::UserAttribute>>;
};


namespace schema {

namespace Code {

namespace Hack {

struct Annotations {
  boost::variant<Alt<0, std::vector<Fact<facebook::glean::cpp::schema::Hack::UserAttribute>>>> GLEAN_value;

  static Annotations attributes(const std::vector<Fact<facebook::glean::cpp::schema::Hack::UserAttribute>>& a) {
    return Annotations{Alt<0, std::vector<Fact<facebook::glean::cpp::schema::Hack::UserAttribute>>>(a)};
  }

  bool operator==(const Annotations& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Annotations& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Annotations& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Annotations>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Annotations

} // namespace Hack

} // namespace Code

namespace Codemarkup {

namespace Hack {

struct HackAnnotation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Code::Hack::Annotations>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackAnnotation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackAnnotation

} // namespace Hack

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Graphql::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Graphql::Declaration>>;
};


namespace schema {

namespace Code {

namespace Graphql {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Graphql::Declaration>> GLEAN_value;

  static Entity decl(const facebook::glean::cpp::schema::Graphql::Declaration& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Graphql::Declaration>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Graphql

} // namespace Code

namespace Codemarkup {

namespace Graphql {

struct GraphQLEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Graphql::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.graphql.GraphQLEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct GraphQLEntityKind

struct GraphQLEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Graphql::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.graphql.GraphQLEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct GraphQLEntityLocation

struct GraphQLEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Graphql::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.graphql.GraphQLEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct GraphQLEntityUses

struct GraphQLFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Graphql::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.graphql.GraphQLFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct GraphQLFileEntityXRefLocations

struct GraphQLResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Graphql::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.graphql.GraphQLResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct GraphQLResolveLocation

} // namespace Graphql

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Flow::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Flow::SomeDeclaration>, facebook::glean::cpp::schema::Flow::Module>;
};


namespace schema {

namespace Code {

namespace Flow {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Flow::SomeDeclaration>, Alt<1, Fact<facebook::glean::cpp::schema::Flow::Module>>> GLEAN_value;

  static Entity decl(const facebook::glean::cpp::schema::Flow::SomeDeclaration& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Flow::SomeDeclaration>(a)};
  }
  static Entity module_(const Fact<facebook::glean::cpp::schema::Flow::Module>& a) {
    return Entity{Alt<1, Fact<facebook::glean::cpp::schema::Flow::Module>>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Flow

} // namespace Code

namespace Codemarkup {

namespace Flow {

struct FlowContainsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Flow::Entity, facebook::glean::cpp::schema::Code::Flow::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowContainsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowContainsChildEntity

struct FlowContainsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Flow::Entity, facebook::glean::cpp::schema::Code::Flow::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowContainsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowContainsParentEntity

struct FlowEntityDocumentation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Flow::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowEntityDocumentation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowEntityDocumentation

struct FlowEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Flow::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowEntityKind

struct FlowEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Flow::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowEntityLocation

struct FlowEntityModuleName : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Flow::Entity, std::string>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowEntityModuleName";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowEntityModuleName

struct FlowEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Flow::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowEntityUses

struct FlowFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Flow::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowFileEntityXRefLocations

struct FlowFileImportDeclEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Flow::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowFileImportDeclEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowFileImportDeclEntityXRefLocations

struct FlowFileReferenceEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Flow::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowFileReferenceEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowFileReferenceEntityXRefLocations

struct FlowResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Flow::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.flow.FlowResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct FlowResolveLocation

} // namespace Flow

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Fbthrift::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Fbthrift::Declaration>>;
};


namespace schema {

namespace Code {

namespace Fbthrift {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Fbthrift::Declaration>> GLEAN_value;

  static Entity decl(const facebook::glean::cpp::schema::Fbthrift::Declaration& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Fbthrift::Declaration>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Fbthrift

} // namespace Code

namespace Codemarkup {

namespace Fbthrift {

struct FbthriftEntityDocumentation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Fbthrift::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.fbthrift.FbthriftEntityDocumentation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FbthriftEntityDocumentation

struct FbthriftEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Fbthrift::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "codemarkup.fbthrift.FbthriftEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FbthriftEntityUses

struct ThriftContainsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Fbthrift::Entity, facebook::glean::cpp::schema::Code::Fbthrift::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.fbthrift.ThriftContainsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ThriftContainsChildEntity

struct ThriftContainsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Fbthrift::Entity, facebook::glean::cpp::schema::Code::Fbthrift::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.fbthrift.ThriftContainsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ThriftContainsParentEntity

struct ThriftEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Fbthrift::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.fbthrift.ThriftEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ThriftEntityKind

struct ThriftEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Fbthrift::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.fbthrift.ThriftEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ThriftEntityLocation

struct ThriftExtendsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Fbthrift::Entity, facebook::glean::cpp::schema::Code::Fbthrift::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.fbthrift.ThriftExtendsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ThriftExtendsChildEntity

struct ThriftExtendsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Fbthrift::Entity, facebook::glean::cpp::schema::Code::Fbthrift::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.fbthrift.ThriftExtendsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ThriftExtendsParentEntity

struct ThriftFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Fbthrift::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.fbthrift.ThriftFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ThriftFileEntityXRefLocations

struct ThriftResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Fbthrift::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.fbthrift.ThriftResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct ThriftResolveLocation

} // namespace Fbthrift

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Fbthrift::Annotations> {
  using Type = Sum<Array<facebook::glean::cpp::schema::Fbthrift::StructuredAnnotation>>;
};


namespace schema {

namespace Code {

namespace Fbthrift {

struct Annotations {
  boost::variant<Alt<0, std::vector<Fact<facebook::glean::cpp::schema::Fbthrift::StructuredAnnotation>>>> GLEAN_value;

  static Annotations annotations(const std::vector<Fact<facebook::glean::cpp::schema::Fbthrift::StructuredAnnotation>>& a) {
    return Annotations{Alt<0, std::vector<Fact<facebook::glean::cpp::schema::Fbthrift::StructuredAnnotation>>>(a)};
  }

  bool operator==(const Annotations& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Annotations& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Annotations& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Annotations>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Annotations

} // namespace Fbthrift

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Erlang::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Erlang::Declaration>>;
};


namespace schema {

namespace Code {

namespace Erlang {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Erlang::Declaration>> GLEAN_value;

  static Entity decl(const facebook::glean::cpp::schema::Erlang::Declaration& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Erlang::Declaration>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Erlang

} // namespace Code

namespace Codemarkup {

namespace Erlang {

struct ErlangEntityDocumentation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Erlang::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.erlang.ErlangEntityDocumentation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ErlangEntityDocumentation

struct ErlangEntityInfo : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Erlang::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.erlang.ErlangEntityInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ErlangEntityInfo

struct ErlangEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Erlang::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.erlang.ErlangEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ErlangEntityKind

struct ErlangEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Erlang::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.erlang.ErlangEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ErlangEntityLocation

struct ErlangEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Erlang::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.erlang.ErlangEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ErlangEntityUses

struct ErlangFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Erlang::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.erlang.ErlangFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ErlangFileEntityXRefLocations

struct ErlangResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Erlang::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.erlang.ErlangResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ErlangResolveLocation

} // namespace Erlang

} // namespace Codemarkup

namespace Search {

namespace Erlang {

struct SearchByFQN : Predicate<std::tuple<std::string, std::string, uint64_t, facebook::glean::cpp::schema::Code::Erlang::Entity>> {
  static const char* GLEAN_name() {
    return "search.erlang.SearchByFQN";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchByFQN

struct SearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Erlang::Entity>> {
  static const char* GLEAN_name() {
    return "search.erlang.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchByName

} // namespace Erlang

} // namespace Search

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Dataswarm::Entity> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Dataswarm::Declaration>>;
};


namespace schema {

namespace Code {

namespace Dataswarm {

struct Entity {
  facebook::glean::cpp::schema::Dataswarm::Declaration decl;

  bool operator==(const Entity& other) const {
    return std::tie(decl)
             == std::tie(other.decl);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(decl)
             != std::tie(other.decl);
  }
  bool operator<(const Entity& other) const {
    return std::tie(decl)
             < std::tie(other.decl);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(decl)
             <= std::tie(other.decl);
  }
  bool operator>(const Entity& other) const {
    return std::tie(decl)
             > std::tie(other.decl);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(decl)
             >= std::tie(other.decl);
  }
  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, std::make_tuple(decl));
  }
}; // struct Entity

} // namespace Dataswarm

} // namespace Code

namespace Codemarkup {

namespace Dataswarm {

struct DataswarmFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Dataswarm::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.dataswarm.DataswarmFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DataswarmFileEntityXRefLocations

} // namespace Dataswarm

} // namespace Codemarkup

namespace Code {

namespace Cxx {

using SymbolId = facebook::glean::cpp::schema::Cxx1::USR;

} // namespace Cxx

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Cxx::ObjcMethodEntity> {
  using Type = Sum<facebook::glean::cpp::schema::Cxx1::ObjcMethodDeclaration, facebook::glean::cpp::schema::Cxx1::ObjcMethodDefinition>;
};


namespace schema {

namespace Code {

namespace Cxx {

struct ObjcMethodEntity {
  boost::variant<Alt<0, Fact<facebook::glean::cpp::schema::Cxx1::ObjcMethodDeclaration>>, Alt<1, Fact<facebook::glean::cpp::schema::Cxx1::ObjcMethodDefinition>>> GLEAN_value;

  static ObjcMethodEntity decl(const Fact<facebook::glean::cpp::schema::Cxx1::ObjcMethodDeclaration>& a) {
    return ObjcMethodEntity{Alt<0, Fact<facebook::glean::cpp::schema::Cxx1::ObjcMethodDeclaration>>(a)};
  }
  static ObjcMethodEntity defn(const Fact<facebook::glean::cpp::schema::Cxx1::ObjcMethodDefinition>& a) {
    return ObjcMethodEntity{Alt<1, Fact<facebook::glean::cpp::schema::Cxx1::ObjcMethodDefinition>>(a)};
  }

  bool operator==(const ObjcMethodEntity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const ObjcMethodEntity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const ObjcMethodEntity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const ObjcMethodEntity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const ObjcMethodEntity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const ObjcMethodEntity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<ObjcMethodEntity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct ObjcMethodEntity

} // namespace Cxx

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Cxx::ObjcSelectorSlotEntity> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Code::Cxx::ObjcMethodEntity>, Nat>;
};


namespace schema {

namespace Code {

namespace Cxx {

struct ObjcSelectorSlotEntity {
  ObjcMethodEntity objcMethod;
  uint64_t index;

  bool operator==(const ObjcSelectorSlotEntity& other) const {
    return std::tie(objcMethod,index)
             == std::tie(other.objcMethod,other.index);
  }
  bool operator!=(const ObjcSelectorSlotEntity& other) const {
    return std::tie(objcMethod,index)
             != std::tie(other.objcMethod,other.index);
  }
  bool operator<(const ObjcSelectorSlotEntity& other) const {
    return std::tie(objcMethod,index)
             < std::tie(other.objcMethod,other.index);
  }
  bool operator<=(const ObjcSelectorSlotEntity& other) const {
    return std::tie(objcMethod,index)
             <= std::tie(other.objcMethod,other.index);
  }
  bool operator>(const ObjcSelectorSlotEntity& other) const {
    return std::tie(objcMethod,index)
             > std::tie(other.objcMethod,other.index);
  }
  bool operator>=(const ObjcSelectorSlotEntity& other) const {
    return std::tie(objcMethod,index)
             >= std::tie(other.objcMethod,other.index);
  }
  void outputRepr(Output<Repr<ObjcSelectorSlotEntity>> out) const {
    outputValue(out, std::make_tuple(objcMethod, index));
  }
}; // struct ObjcSelectorSlotEntity

} // namespace Cxx

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Cxx::Definition> {
  using Type = Sum<facebook::glean::cpp::schema::Cxx1::RecordDefinition, facebook::glean::cpp::schema::Cxx1::FunctionDefinition, facebook::glean::cpp::schema::Cxx1::EnumDefinition, facebook::glean::cpp::schema::Cxx1::ObjcMethodDefinition, facebook::glean::cpp::schema::Cxx1::ObjcContainerDefinition, facebook::glean::cpp::schema::Cxx1::VariableDeclaration, facebook::glean::cpp::schema::Cxx1::NamespaceDefinition>;
};


namespace schema {

namespace Code {

namespace Cxx {

struct Definition {
  boost::variant<Alt<0, Fact<facebook::glean::cpp::schema::Cxx1::RecordDefinition>>, Alt<1, Fact<facebook::glean::cpp::schema::Cxx1::FunctionDefinition>>, Alt<2, Fact<facebook::glean::cpp::schema::Cxx1::EnumDefinition>>, Alt<3, Fact<facebook::glean::cpp::schema::Cxx1::ObjcMethodDefinition>>, Alt<4, Fact<facebook::glean::cpp::schema::Cxx1::ObjcContainerDefinition>>, Alt<5, Fact<facebook::glean::cpp::schema::Cxx1::VariableDeclaration>>, Alt<6, Fact<facebook::glean::cpp::schema::Cxx1::NamespaceDefinition>>> GLEAN_value;

  static Definition record_(const Fact<facebook::glean::cpp::schema::Cxx1::RecordDefinition>& a) {
    return Definition{Alt<0, Fact<facebook::glean::cpp::schema::Cxx1::RecordDefinition>>(a)};
  }
  static Definition function_(const Fact<facebook::glean::cpp::schema::Cxx1::FunctionDefinition>& a) {
    return Definition{Alt<1, Fact<facebook::glean::cpp::schema::Cxx1::FunctionDefinition>>(a)};
  }
  static Definition enum_(const Fact<facebook::glean::cpp::schema::Cxx1::EnumDefinition>& a) {
    return Definition{Alt<2, Fact<facebook::glean::cpp::schema::Cxx1::EnumDefinition>>(a)};
  }
  static Definition objcMethod(const Fact<facebook::glean::cpp::schema::Cxx1::ObjcMethodDefinition>& a) {
    return Definition{Alt<3, Fact<facebook::glean::cpp::schema::Cxx1::ObjcMethodDefinition>>(a)};
  }
  static Definition objcContainer(const Fact<facebook::glean::cpp::schema::Cxx1::ObjcContainerDefinition>& a) {
    return Definition{Alt<4, Fact<facebook::glean::cpp::schema::Cxx1::ObjcContainerDefinition>>(a)};
  }
  static Definition variable(const Fact<facebook::glean::cpp::schema::Cxx1::VariableDeclaration>& a) {
    return Definition{Alt<5, Fact<facebook::glean::cpp::schema::Cxx1::VariableDeclaration>>(a)};
  }
  static Definition namespace_(const Fact<facebook::glean::cpp::schema::Cxx1::NamespaceDefinition>& a) {
    return Definition{Alt<6, Fact<facebook::glean::cpp::schema::Cxx1::NamespaceDefinition>>(a)};
  }

  bool operator==(const Definition& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Definition& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Definition& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Definition& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Definition& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Definition& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Definition>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Definition

} // namespace Cxx

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Cxx::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Cxx1::Declaration>, Repr<facebook::glean::cpp::schema::Code::Cxx::Definition>, facebook::glean::cpp::schema::Cxx1::Enumerator, Repr<facebook::glean::cpp::schema::Code::Cxx::ObjcSelectorSlotEntity>>;
};


namespace schema {

namespace Code {

namespace Cxx {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Cxx1::Declaration>, Alt<1, Definition>, Alt<2, Fact<facebook::glean::cpp::schema::Cxx1::Enumerator>>, Alt<3, ObjcSelectorSlotEntity>> GLEAN_value;

  static Entity decl(const facebook::glean::cpp::schema::Cxx1::Declaration& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Cxx1::Declaration>(a)};
  }
  static Entity defn(const Definition& a) {
    return Entity{Alt<1, Definition>(a)};
  }
  static Entity enumerator(const Fact<facebook::glean::cpp::schema::Cxx1::Enumerator>& a) {
    return Entity{Alt<2, Fact<facebook::glean::cpp::schema::Cxx1::Enumerator>>(a)};
  }
  static Entity objcSelectorSlot(const ObjcSelectorSlotEntity& a) {
    return Entity{Alt<3, ObjcSelectorSlotEntity>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Cxx

} // namespace Code

namespace Codemarkup {

namespace Cxx {

struct CxxContainsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxContainsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxContainsChildEntity

struct CxxContainsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxContainsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxContainsParentEntity

struct CxxDeclToDefXRefTargetLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDeclToDefXRefTargetLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDeclToDefXRefTargetLocation

struct CxxDeclarationContainsChild : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDeclarationContainsChild";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDeclarationContainsChild

struct CxxDeclarationContainsParent : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDeclarationContainsParent";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDeclarationContainsParent

struct CxxDeclarationExtendsChild : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDeclarationExtendsChild";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDeclarationExtendsChild

struct CxxDeclarationExtendsParent : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDeclarationExtendsParent";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDeclarationExtendsParent

struct CxxDeclarationSource : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDeclarationSource";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDeclarationSource

struct CxxDefToDeclFamilyXRefTargetLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDefToDeclFamilyXRefTargetLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDefToDeclFamilyXRefTargetLocation

struct CxxEntityDocumentation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxEntityDocumentation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxEntityDocumentation

struct CxxEntityInfo : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxEntityInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxEntityInfo

struct CxxEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxEntityKind

struct CxxEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxEntityLocation

struct CxxEntityMangledNameHash : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Cxx1::MangledNameHash>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxEntityMangledNameHash";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxEntityMangledNameHash

struct CxxEntitySource : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxEntitySource";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxEntitySource

struct CxxEntityUSR : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Cxx1::USR>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxEntityUSR";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxEntityUSR

struct CxxEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxEntityUses

struct CxxExtendsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxExtendsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxExtendsChildEntity

struct CxxExtendsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxExtendsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxExtendsParentEntity

struct CxxFileEntitySpellingXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxFileEntitySpellingXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxFileEntitySpellingXRefLocations

struct CxxFileEntityTraceDeclToDefXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<facebook::glean::cpp::schema::Cxx1::Trace>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxFileEntityTraceDeclToDefXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxFileEntityTraceDeclToDefXRefLocations

struct CxxFileEntityXMapFixedXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::FileXRefs>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxFileEntityXMapFixedXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxFileEntityXMapFixedXRefLocations

struct CxxFileEntityXMapVariableXRefDeclToDefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::FileXRefs>, facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxFileEntityXMapVariableXRefDeclToDefs";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxFileEntityXMapVariableXRefDeclToDefs

struct CxxFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxFileEntityXRefLocations

struct CxxFindDefinitionOfEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxFindDefinitionOfEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxFindDefinitionOfEntity

struct CxxModifiers : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Modifiers>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxModifiers";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxModifiers

struct CxxNamespaceDeclarationContainsChild : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::NamespaceDeclaration>, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxNamespaceDeclarationContainsChild";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxNamespaceDeclarationContainsChild

struct CxxResolveDeclarationToEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxResolveDeclarationToEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxResolveDeclarationToEntity

struct CxxResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxResolveLocation

struct CxxResolveTraceLocation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::Trace>, facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxResolveTraceLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxResolveTraceLocation

struct CxxVisibility : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Visibility>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxVisibility";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxVisibility

struct CxxXRefTargetLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::XRefTarget, facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxXRefTargetLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxXRefTargetLocation

struct EntityToXRefTarget : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Cxx1::XRefTarget>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.EntityToXRefTarget";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct EntityToXRefTarget

struct SymbolToEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::SymbolId, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.SymbolToEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SymbolToEntity

struct XRefTargetToEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::XRefTarget, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.XRefTargetToEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct XRefTargetToEntity

} // namespace Cxx

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Glean::Test::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Code::Cxx::Entity>, facebook::glean::cpp::schema::Pp1::Define>;
};


namespace schema {

namespace Glean {

namespace Test {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Code::Cxx::Entity>, Alt<1, Fact<facebook::glean::cpp::schema::Pp1::Define>>> GLEAN_value;

  static Entity cxx(const facebook::glean::cpp::schema::Code::Cxx::Entity& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Code::Cxx::Entity>(a)};
  }
  static Entity pp(const Fact<facebook::glean::cpp::schema::Pp1::Define>& a) {
    return Entity{Alt<1, Fact<facebook::glean::cpp::schema::Pp1::Define>>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Test

} // namespace Glean

namespace Search {

namespace Code {

struct CxxPreferDefinitions : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.CxxPreferDefinitions";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct CxxPreferDefinitions

} // namespace Code

namespace Kind {

namespace Cxx {

struct SearchObjcInterface : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "search.kind.cxx.SearchObjcInterface";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchObjcInterface

} // namespace Cxx

} // namespace Kind

} // namespace Search

namespace Symbolid {

namespace Cxx {

struct DefinitionOfDecl : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.DefinitionOfDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DefinitionOfDecl

struct LookupNamespaceDefinition : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Cxx1::Name>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Cxx1::NamespaceQName>>>, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.LookupNamespaceDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupNamespaceDefinition

} // namespace Cxx

} // namespace Symbolid

namespace Codemarkup {

namespace Cxx {

struct CxxDefinitionContainsChild : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Definition, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDefinitionContainsChild";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDefinitionContainsChild

struct CxxDefinitionContainsParent : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Definition, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDefinitionContainsParent";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDefinitionContainsParent

struct CxxDefinitionExtendsChild : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Definition, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDefinitionExtendsChild";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDefinitionExtendsChild

struct CxxDefinitionExtendsParent : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Definition, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDefinitionExtendsParent";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDefinitionExtendsParent

struct CxxDefinitionModifiers : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Definition, facebook::glean::cpp::schema::Codemarkup::Types::Modifiers>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDefinitionModifiers";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDefinitionModifiers

struct CxxDefnVisibility : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Definition, facebook::glean::cpp::schema::Codemarkup::Types::Visibility>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxDefnVisibility";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxDefnVisibility

struct CxxEntityDefinitionBase : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Definition, facebook::glean::cpp::schema::Cxx1::Declaration>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxEntityDefinitionBase";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxEntityDefinitionBase

} // namespace Cxx

} // namespace Codemarkup

namespace Search {

namespace Cxx {

struct DeclIsDefn : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, facebook::glean::cpp::schema::Code::Cxx::Definition>> {
  static const char* GLEAN_name() {
    return "search.cxx.DeclIsDefn";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclIsDefn

} // namespace Cxx

} // namespace Search

namespace Code {

namespace Cxx {

struct DeclToDef : Predicate<std::tuple<facebook::glean::cpp::schema::Cxx1::Declaration, Definition>> {
  static const char* GLEAN_name() {
    return "code.cxx.DeclToDef";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DeclToDef

} // namespace Cxx

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Cxx::Annotations> {
  using Type = Sum<Array<facebook::glean::cpp::schema::Cxx1::Attribute>>;
};


namespace schema {

namespace Code {

namespace Cxx {

struct Annotations {
  boost::variant<Alt<0, std::vector<Fact<facebook::glean::cpp::schema::Cxx1::Attribute>>>> GLEAN_value;

  static Annotations attributes(const std::vector<Fact<facebook::glean::cpp::schema::Cxx1::Attribute>>& a) {
    return Annotations{Alt<0, std::vector<Fact<facebook::glean::cpp::schema::Cxx1::Attribute>>>(a)};
  }

  bool operator==(const Annotations& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Annotations& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Annotations& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Annotations>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Annotations

} // namespace Cxx

} // namespace Code

namespace Codemarkup {

namespace Cxx {

struct CxxAnnotation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Code::Cxx::Annotations>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxAnnotation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxAnnotation

} // namespace Cxx

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Csharp::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Csharp::Definition>>;
};


namespace schema {

namespace Code {

namespace Csharp {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Csharp::Definition>> GLEAN_value;

  static Entity decl(const facebook::glean::cpp::schema::Csharp::Definition& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Csharp::Definition>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Csharp

} // namespace Code

namespace Codemarkup {

namespace Csharp {

struct CSharpEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Csharp::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.csharp.CSharpEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct CSharpEntityKind

struct CSharpEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Csharp::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.csharp.CSharpEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct CSharpEntityLocation

struct CSharpEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Csharp::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.csharp.CSharpEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct CSharpEntityUses

struct CSharpFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Csharp::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.csharp.CSharpFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct CSharpFileEntityXRefLocations

struct CSharpResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Csharp::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.csharp.CSharpResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct CSharpResolveLocation

} // namespace Csharp

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Buck::Entity> {
  using Type = Sum<facebook::glean::cpp::schema::Buck::Locator, facebook::glean::cpp::schema::Src::File, facebook::glean::cpp::schema::Buck::Definition>;
};


namespace schema {

namespace Code {

namespace Buck {

struct Entity {
  boost::variant<Alt<0, Fact<facebook::glean::cpp::schema::Buck::Locator>>, Alt<1, Fact<facebook::glean::cpp::schema::Src::File>>, Alt<2, Fact<facebook::glean::cpp::schema::Buck::Definition>>> GLEAN_value;

  static Entity locator(const Fact<facebook::glean::cpp::schema::Buck::Locator>& a) {
    return Entity{Alt<0, Fact<facebook::glean::cpp::schema::Buck::Locator>>(a)};
  }
  static Entity file(const Fact<facebook::glean::cpp::schema::Src::File>& a) {
    return Entity{Alt<1, Fact<facebook::glean::cpp::schema::Src::File>>(a)};
  }
  static Entity definition(const Fact<facebook::glean::cpp::schema::Buck::Definition>& a) {
    return Entity{Alt<2, Fact<facebook::glean::cpp::schema::Buck::Definition>>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Buck

} // namespace Code

namespace Codemarkup {

namespace Buck {

struct BuckEntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Buck::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.buck.BuckEntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct BuckEntityKind

struct BuckEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Buck::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.buck.BuckEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct BuckEntityLocation

struct BuckEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Buck::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.buck.BuckEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct BuckEntityUses

struct BuckFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Buck::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.buck.BuckFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct BuckFileEntityXRefLocations

struct BuckResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Buck::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.buck.BuckResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct BuckResolveLocation

} // namespace Buck

} // namespace Codemarkup

namespace Search {

namespace Buck {

struct SearchByFQN : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, std::string, std::string, facebook::glean::cpp::schema::Code::Buck::Entity>> {
  static const char* GLEAN_name() {
    return "search.buck.SearchByFQN";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchByFQN

struct SearchDefinition : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::string, facebook::glean::cpp::schema::Code::Buck::Entity>> {
  static const char* GLEAN_name() {
    return "search.buck.SearchDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchDefinition

struct SearchFile : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Code::Buck::Entity>> {
  static const char* GLEAN_name() {
    return "search.buck.SearchFile";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchFile

} // namespace Buck

} // namespace Search

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::SymbolId> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Code::Scip::SymbolId>, Repr<facebook::glean::cpp::schema::Code::Cxx::SymbolId>>;
};


namespace schema {

namespace Code {

struct SymbolId {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Code::Scip::SymbolId>, Alt<1, facebook::glean::cpp::schema::Code::Cxx::SymbolId>> GLEAN_value;

  static SymbolId scip(const facebook::glean::cpp::schema::Code::Scip::SymbolId& a) {
    return SymbolId{Alt<0, facebook::glean::cpp::schema::Code::Scip::SymbolId>(a)};
  }
  static SymbolId cxx(const facebook::glean::cpp::schema::Code::Cxx::SymbolId& a) {
    return SymbolId{Alt<1, facebook::glean::cpp::schema::Code::Cxx::SymbolId>(a)};
  }

  bool operator==(const SymbolId& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const SymbolId& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const SymbolId& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const SymbolId& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const SymbolId& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const SymbolId& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<SymbolId>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct SymbolId

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Language> {
  using Type = Enum<23>;
};


namespace schema {

namespace Code {

enum class Language { Cpp, PreProcessor, Java, Haskell, Python, Hack, JavaScript, Rust, Thrift, Buck, Erlang, FSharp, Go, Kotlin, OCaml, Scala, Swift, TypeScript, CSharp, GraphQL, Dataswarm, Yaml, Angle };

struct EntityLanguageSCIP : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Scip::Entity, Language>> {
  static const char* GLEAN_name() {
    return "code.EntityLanguageSCIP";
  }

  static constexpr size_t GLEAN_version() {
     return 24;
  }
}; // struct EntityLanguageSCIP

struct EntityLanguageLSIF : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Lsif::Entity, Language>> {
  static const char* GLEAN_name() {
    return "code.EntityLanguageLSIF";
  }

  static constexpr size_t GLEAN_version() {
     return 24;
  }
}; // struct EntityLanguageLSIF

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Annotations> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Code::Cxx::Annotations>, Repr<facebook::glean::cpp::schema::Code::Java::Annotations>, Repr<facebook::glean::cpp::schema::Code::Python::Annotations>, Repr<facebook::glean::cpp::schema::Code::Hack::Annotations>, Repr<facebook::glean::cpp::schema::Code::Fbthrift::Annotations>>;
};


namespace schema {

namespace Code {

struct Annotations {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Code::Cxx::Annotations>, Alt<1, facebook::glean::cpp::schema::Code::Java::Annotations>, Alt<2, facebook::glean::cpp::schema::Code::Python::Annotations>, Alt<3, facebook::glean::cpp::schema::Code::Hack::Annotations>, Alt<4, facebook::glean::cpp::schema::Code::Fbthrift::Annotations>> GLEAN_value;

  static Annotations cxx(const facebook::glean::cpp::schema::Code::Cxx::Annotations& a) {
    return Annotations{Alt<0, facebook::glean::cpp::schema::Code::Cxx::Annotations>(a)};
  }
  static Annotations java(const facebook::glean::cpp::schema::Code::Java::Annotations& a) {
    return Annotations{Alt<1, facebook::glean::cpp::schema::Code::Java::Annotations>(a)};
  }
  static Annotations python(const facebook::glean::cpp::schema::Code::Python::Annotations& a) {
    return Annotations{Alt<2, facebook::glean::cpp::schema::Code::Python::Annotations>(a)};
  }
  static Annotations hack(const facebook::glean::cpp::schema::Code::Hack::Annotations& a) {
    return Annotations{Alt<3, facebook::glean::cpp::schema::Code::Hack::Annotations>(a)};
  }
  static Annotations fbthrift(const facebook::glean::cpp::schema::Code::Fbthrift::Annotations& a) {
    return Annotations{Alt<4, facebook::glean::cpp::schema::Code::Fbthrift::Annotations>(a)};
  }

  bool operator==(const Annotations& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Annotations& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Annotations& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Annotations& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Annotations>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Annotations

} // namespace Code

namespace Cxx1 {

struct FunctionName : Predicate<boost::variant<Alt<0, Fact<Name>>, Alt<1, Operator>, Alt<2, LiteralOperator>, Alt<3, std::tuple<>>, Alt<4, std::tuple<>>, Alt<5, Fact<Type>>>> {
  static const char* GLEAN_name() {
    return "cxx1.FunctionName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FunctionName

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::RecordKind> {
  using Type = Sum<Unit, Unit, Unit>;
};


namespace schema {

namespace Cxx1 {

struct RecordKind {
  boost::variant<Alt<0, std::tuple<>>, Alt<1, std::tuple<>>, Alt<2, std::tuple<>>> GLEAN_value;

  static RecordKind struct_() {
    return RecordKind{Alt<0, std::tuple<>>(std::make_tuple())};
  }
  static RecordKind class_() {
    return RecordKind{Alt<1, std::tuple<>>(std::make_tuple())};
  }
  static RecordKind union_() {
    return RecordKind{Alt<2, std::tuple<>>(std::make_tuple())};
  }

  bool operator==(const RecordKind& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const RecordKind& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const RecordKind& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const RecordKind& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const RecordKind& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const RecordKind& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<RecordKind>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct RecordKind

struct RecordDeclaration : Predicate<std::tuple<Fact<QName>, RecordKind, facebook::glean::cpp::schema::Src::Range>> {
  static const char* GLEAN_name() {
    return "cxx1.RecordDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct RecordDeclaration

} // namespace Cxx1

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Cxx1::Scope> {
  using Type = Sum<Unit, facebook::glean::cpp::schema::Cxx1::NamespaceQName, Tuple<facebook::glean::cpp::schema::Cxx1::QName, Repr<facebook::glean::cpp::schema::Cxx1::Access>>, facebook::glean::cpp::schema::Cxx1::FunctionQName>;
};


namespace schema {

namespace Cxx1 {

struct Scope {
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<NamespaceQName>>, Alt<2, std::tuple<Fact<QName>, Access>>, Alt<3, Fact<FunctionQName>>> GLEAN_value;

  static Scope global_() {
    return Scope{Alt<0, std::tuple<>>(std::make_tuple())};
  }
  static Scope namespace_(const Fact<NamespaceQName>& a) {
    return Scope{Alt<1, Fact<NamespaceQName>>(a)};
  }
  static Scope recordWithAccess(const Fact<QName>& record, const Access& access) {
    return Scope{Alt<2, std::tuple<Fact<QName>, Access>>(std::make_tuple(record, access))};
  }
  static Scope local(const Fact<FunctionQName>& a) {
    return Scope{Alt<3, Fact<FunctionQName>>(a)};
  }

  bool operator==(const Scope& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Scope& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Scope& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Scope& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Scope& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Scope& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Scope>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Scope

struct DeclarationScope : Predicate<std::tuple<Declaration, Scope>> {
  static const char* GLEAN_name() {
    return "cxx1.DeclarationScope";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct DeclarationScope

struct EnumDeclarationByName : Predicate<std::tuple<std::string, Scope, Fact<EnumDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.EnumDeclarationByName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct EnumDeclarationByName

struct FunctionDeclarationByNameScope : Predicate<std::tuple<std::string, Scope, Fact<FunctionDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.FunctionDeclarationByNameScope";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FunctionDeclarationByNameScope

struct FunctionQName : Predicate<std::tuple<Fact<FunctionName>, Scope>> {
  static const char* GLEAN_name() {
    return "cxx1.FunctionQName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct FunctionQName

struct QName : Predicate<std::tuple<Fact<Name>, Scope>> {
  static const char* GLEAN_name() {
    return "cxx1.QName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct QName

struct RecordDeclarationClass : Predicate<std::tuple<std::string, Scope, Fact<RecordDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.RecordDeclarationClass";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct RecordDeclarationClass

struct RecordDeclarationStruct : Predicate<std::tuple<std::string, Scope, Fact<RecordDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.RecordDeclarationStruct";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct RecordDeclarationStruct

struct RecordDeclarationUnion : Predicate<std::tuple<std::string, Scope, Fact<RecordDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.RecordDeclarationUnion";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct RecordDeclarationUnion

struct TypeAliasDeclarationByName : Predicate<std::tuple<std::string, Scope, Fact<TypeAliasDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.TypeAliasDeclarationByName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct TypeAliasDeclarationByName

struct VariableDeclarationNonLocalByName : Predicate<std::tuple<std::string, Scope, Fact<VariableDeclaration>>> {
  static const char* GLEAN_name() {
    return "cxx1.VariableDeclarationNonLocalByName";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct VariableDeclarationNonLocalByName

} // namespace Cxx1

namespace Search {

namespace Cxx {

struct QueryToScopeCase : Predicate<std::tuple<std::vector<std::string>, bool, facebook::glean::cpp::schema::Cxx1::Scope>> {
  static const char* GLEAN_name() {
    return "search.cxx.QueryToScopeCase";
  }

  static constexpr size_t GLEAN_version() {
     return 5;
  }
}; // struct QueryToScopeCase

} // namespace Cxx

namespace Kind {

namespace Cxx {

struct SearchClass : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "search.kind.cxx.SearchClass";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchClass

struct SearchEnum : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "search.kind.cxx.SearchEnum";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchEnum

struct SearchEnumerator : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "search.kind.cxx.SearchEnumerator";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchEnumerator

struct SearchFunction : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "search.kind.cxx.SearchFunction";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchFunction

struct SearchNamespace : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "search.kind.cxx.SearchNamespace";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchNamespace

struct SearchStruct : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "search.kind.cxx.SearchStruct";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchStruct

struct SearchTypeAlias : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "search.kind.cxx.SearchTypeAlias";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchTypeAlias

struct SearchUnion : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "search.kind.cxx.SearchUnion";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchUnion

struct SearchVariable : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "search.kind.cxx.SearchVariable";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchVariable

} // namespace Cxx

} // namespace Kind

} // namespace Search

namespace Symbolid {

namespace Cxx {

struct LookupDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::Name>, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Cxx1::Declaration>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.LookupDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupDeclaration

struct LookupDefinition : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::Name>, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.LookupDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupDefinition

struct LookupEnumerator : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::Name>, Fact<facebook::glean::cpp::schema::Cxx1::Name>, facebook::glean::cpp::schema::Cxx1::Scope, Fact<facebook::glean::cpp::schema::Cxx1::Enumerator>>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.LookupEnumerator";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupEnumerator

struct LookupFunctionDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::FunctionName>, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Cxx1::Declaration>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.LookupFunctionDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupFunctionDeclaration

struct LookupFunctionDefinition : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::FunctionName>, facebook::glean::cpp::schema::Cxx1::Scope, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.LookupFunctionDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupFunctionDefinition

struct LookupFunctionSignatureDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::FunctionName>, facebook::glean::cpp::schema::Cxx1::Scope, Fact<facebook::glean::cpp::schema::Cxx1::Signature>, facebook::glean::cpp::schema::Cxx1::Declaration>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.LookupFunctionSignatureDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupFunctionSignatureDeclaration

struct LookupFunctionSignatureDefinition : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::FunctionName>, facebook::glean::cpp::schema::Cxx1::Scope, Fact<facebook::glean::cpp::schema::Cxx1::Signature>, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.LookupFunctionSignatureDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupFunctionSignatureDefinition

struct LookupFunctionSignatureQualifierDeclaration : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::FunctionName>, facebook::glean::cpp::schema::Cxx1::Scope, Fact<facebook::glean::cpp::schema::Cxx1::Signature>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Cxx1::MethodSignature>>, facebook::glean::cpp::schema::Cxx1::Declaration>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.LookupFunctionSignatureQualifierDeclaration";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupFunctionSignatureQualifierDeclaration

struct LookupFunctionSignatureQualifierDefinition : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::FunctionName>, facebook::glean::cpp::schema::Cxx1::Scope, Fact<facebook::glean::cpp::schema::Cxx1::Signature>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Cxx1::MethodSignature>>, facebook::glean::cpp::schema::Code::Cxx::Entity>> {
  static const char* GLEAN_name() {
    return "symbolid.cxx.LookupFunctionSignatureQualifierDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct LookupFunctionSignatureQualifierDefinition

} // namespace Cxx

} // namespace Symbolid

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Fbthrift::ResultType> {
  using Type = Sum<Unit, Unit, facebook::glean::cpp::schema::Fbthrift::TypeSpecification, Repr<facebook::glean::cpp::schema::Fbthrift::ResultStream>, facebook::glean::cpp::schema::Fbthrift::ServiceName, Repr<facebook::glean::cpp::schema::Fbthrift::ResultSink>>;
};


namespace schema {

namespace Fbthrift {

struct ResultType {
  boost::variant<Alt<0, std::tuple<>>, Alt<1, std::tuple<>>, Alt<2, Fact<TypeSpecification>>, Alt<3, ResultStream>, Alt<4, Fact<ServiceName>>, Alt<5, ResultSink>> GLEAN_value;

  static ResultType oneway_() {
    return ResultType{Alt<0, std::tuple<>>(std::make_tuple())};
  }
  static ResultType void_() {
    return ResultType{Alt<1, std::tuple<>>(std::make_tuple())};
  }
  static ResultType result(const Fact<TypeSpecification>& a) {
    return ResultType{Alt<2, Fact<TypeSpecification>>(a)};
  }
  static ResultType stream_(const ResultStream& a) {
    return ResultType{Alt<3, ResultStream>(a)};
  }
  static ResultType service_(const Fact<ServiceName>& a) {
    return ResultType{Alt<4, Fact<ServiceName>>(a)};
  }
  static ResultType sink_(const ResultSink& a) {
    return ResultType{Alt<5, ResultSink>(a)};
  }

  bool operator==(const ResultType& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const ResultType& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const ResultType& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const ResultType& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const ResultType& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const ResultType& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<ResultType>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct ResultType

struct FunctionSpecification : Predicate<std::tuple<Fact<FunctionName>, ResultType, std::vector<UnqualField>, std::vector<ExceptionSpecification>, std::vector<Fact<StructuredAnnotation>>>> {
  static const char* GLEAN_name() {
    return "fbthrift.FunctionSpecification";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FunctionSpecification

} // namespace Fbthrift

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Buck::XRefDestination> {
  using Type = Sum<facebook::glean::cpp::schema::Buck::Locator, facebook::glean::cpp::schema::Src::File, facebook::glean::cpp::schema::Buck::Definition>;
};


namespace schema {

namespace Buck {

struct XRefDestination {
  boost::variant<Alt<0, Fact<Locator>>, Alt<1, Fact<facebook::glean::cpp::schema::Src::File>>, Alt<2, Fact<Definition>>> GLEAN_value;

  static XRefDestination locator(const Fact<Locator>& a) {
    return XRefDestination{Alt<0, Fact<Locator>>(a)};
  }
  static XRefDestination file(const Fact<facebook::glean::cpp::schema::Src::File>& a) {
    return XRefDestination{Alt<1, Fact<facebook::glean::cpp::schema::Src::File>>(a)};
  }
  static XRefDestination definition(const Fact<Definition>& a) {
    return XRefDestination{Alt<2, Fact<Definition>>(a)};
  }

  bool operator==(const XRefDestination& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const XRefDestination& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const XRefDestination& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const XRefDestination& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const XRefDestination& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const XRefDestination& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<XRefDestination>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct XRefDestination

} // namespace Buck

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Buck::XRef> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Buck::XRefDestination>, Array<Repr<facebook::glean::cpp::schema::Src::ByteSpan>>>;
};


namespace schema {

namespace Buck {

struct XRef {
  XRefDestination destination;
  std::vector<facebook::glean::cpp::schema::Src::ByteSpan> ranges;

  bool operator==(const XRef& other) const {
    return std::tie(destination,ranges)
             == std::tie(other.destination,other.ranges);
  }
  bool operator!=(const XRef& other) const {
    return std::tie(destination,ranges)
             != std::tie(other.destination,other.ranges);
  }
  bool operator<(const XRef& other) const {
    return std::tie(destination,ranges)
             < std::tie(other.destination,other.ranges);
  }
  bool operator<=(const XRef& other) const {
    return std::tie(destination,ranges)
             <= std::tie(other.destination,other.ranges);
  }
  bool operator>(const XRef& other) const {
    return std::tie(destination,ranges)
             > std::tie(other.destination,other.ranges);
  }
  bool operator>=(const XRef& other) const {
    return std::tie(destination,ranges)
             >= std::tie(other.destination,other.ranges);
  }
  void outputRepr(Output<Repr<XRef>> out) const {
    outputValue(out, std::make_tuple(destination, ranges));
  }
}; // struct XRef

struct Type : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "buck.Type";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Type

struct TranslationUnit : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Locator>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Platform>>>>> {
  static const char* GLEAN_name() {
    return "buck.TranslationUnit";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TranslationUnit

struct TargetUses : Predicate<std::tuple<Fact<Locator>, Fact<facebook::glean::cpp::schema::Src::File>, std::vector<facebook::glean::cpp::schema::Src::ByteSpan>>> {
  static const char* GLEAN_name() {
    return "buck.TargetUses";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetUses

struct TargetSourcesBaseModule : Predicate<std::tuple<Fact<Target>, std::vector<Fact<File>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<AttributeValue>>>>> {
  static const char* GLEAN_name() {
    return "buck.TargetSourcesBaseModule";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetSourcesBaseModule

struct TargetSources : Predicate<std::tuple<Fact<Target>, std::vector<Fact<File>>, std::vector<Fact<File>>, std::vector<Fact<File>>>> {
  static const char* GLEAN_name() {
    return "buck.TargetSources";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetSources

struct TargetOuts : Predicate<std::tuple<Fact<Target>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<OutputLabel>>>, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "buck.TargetOuts";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetOuts

struct TargetOut : Predicate<std::tuple<Fact<Target>, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "buck.TargetOut";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetOut

struct TargetMode : Predicate<std::tuple<Fact<Target>, std::string>> {
  static const char* GLEAN_name() {
    return "buck.TargetMode";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetMode

struct TargetLocation : Predicate<std::tuple<Fact<Locator>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "buck.TargetLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetLocation

struct TargetLinkWhole : Predicate<Fact<Target>> {
  static const char* GLEAN_name() {
    return "buck.TargetLinkWhole";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetLinkWhole

struct TargetIndexerName : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "buck.TargetIndexerName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetIndexerName

struct TargetIndexer : Predicate<std::tuple<Fact<TargetIndexerName>, Fact<Target>>> {
  static const char* GLEAN_name() {
    return "buck.TargetIndexer";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetIndexer

struct TargetHash : Predicate<std::tuple<Fact<Locator>, std::string>> {
  static const char* GLEAN_name() {
    return "buck.TargetHash";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetHash

struct TargetCallByCallExpr : Predicate<std::tuple<Fact<CallExpr>, Fact<TargetCall>>> {
  static const char* GLEAN_name() {
    return "buck.TargetCallByCallExpr";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetCallByCallExpr

struct TargetCall : Predicate<std::tuple<Fact<Locator>, std::vector<Fact<CallArgument>>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<CallExpr>>>>> {
  static const char* GLEAN_name() {
    return "buck.TargetCall";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetCall

struct TargetByType : Predicate<std::tuple<Fact<Type>, Fact<Target>>> {
  static const char* GLEAN_name() {
    return "buck.TargetByType";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetByType

struct TargetAttribute : Predicate<std::tuple<Fact<Target>, Fact<AttributeName>, Fact<AttributeValue>>> {
  static const char* GLEAN_name() {
    return "buck.TargetAttribute";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetAttribute

struct Target : Predicate<std::tuple<Fact<Locator>, Fact<Type>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Platform>>>, Fact<Labels>>> {
  static const char* GLEAN_name() {
    return "buck.Target";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Target

struct SourceFileLocation : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "buck.SourceFileLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SourceFileLocation

struct SearchByLocalName : Predicate<std::tuple<Fact<LocalName>, XRefDestination>> {
  static const char* GLEAN_name() {
    return "buck.SearchByLocalName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct SearchByLocalName

struct RuleKey : Predicate<std::tuple<Fact<Locator>, std::string>> {
  static const char* GLEAN_name() {
    return "buck.RuleKey";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct RuleKey

struct Platform : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "buck.Platform";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Platform

struct Owner : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<TargetSources>>> {
  static const char* GLEAN_name() {
    return "buck.Owner";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Owner

struct OutsTarget : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Target>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<OutputLabel>>>>> {
  static const char* GLEAN_name() {
    return "buck.OutsTarget";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct OutsTarget

struct OutputLabel : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "buck.OutputLabel";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct OutputLabel

struct OutTarget : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Target>>> {
  static const char* GLEAN_name() {
    return "buck.OutTarget";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct OutTarget

struct LocatorWithLabel : Predicate<std::tuple<Fact<Locator>, Fact<OutputLabel>>> {
  static const char* GLEAN_name() {
    return "buck.LocatorWithLabel";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct LocatorWithLabel

struct LocatorReverseDeps : Predicate<std::tuple<Fact<Locator>, std::vector<Fact<Locator>>>> {
  static const char* GLEAN_name() {
    return "buck.LocatorReverseDeps";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct LocatorReverseDeps

struct LocatorReverseDep : Predicate<std::tuple<Fact<Locator>, Fact<Locator>>> {
  static const char* GLEAN_name() {
    return "buck.LocatorReverseDep";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct LocatorReverseDep

struct Locator : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, std::string, std::string>> {
  static const char* GLEAN_name() {
    return "buck.Locator";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Locator

struct LocalNameLowerCase : Predicate<std::tuple<std::string, Fact<LocalName>>> {
  static const char* GLEAN_name() {
    return "buck.LocalNameLowerCase";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct LocalNameLowerCase

struct LocalName : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "buck.LocalName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct LocalName

struct Labels : Predicate<std::vector<Fact<Label>>> {
  static const char* GLEAN_name() {
    return "buck.Labels";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Labels

struct Label : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "buck.Label";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Label

struct IndexerName : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "buck.IndexerName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct IndexerName

struct FileXRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::vector<XRef>>> {
  static const char* GLEAN_name() {
    return "buck.FileXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FileXRefs

struct FileToTarget : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Locator>>> {
  static const char* GLEAN_name() {
    return "buck.FileToTarget";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FileToTarget

struct FileTarget : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Locator>>> {
  static const char* GLEAN_name() {
    return "buck.FileTarget";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FileTarget

struct FileResolved : Predicate<std::tuple<Fact<File>, Fact<facebook::glean::cpp::schema::Src::File>>> {
  static const char* GLEAN_name() {
    return "buck.FileResolved";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FileResolved

struct FileEntity : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, XRefDestination>> {
  static const char* GLEAN_name() {
    return "buck.FileEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FileEntity

struct FileDefinition : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<Definition>>> {
  static const char* GLEAN_name() {
    return "buck.FileDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FileDefinition

struct File : Predicate<boost::variant<Alt<0, Fact<facebook::glean::cpp::schema::Src::File>>, Alt<1, Fact<Locator>>, Alt<2, Fact<LocatorWithLabel>>>> {
  static const char* GLEAN_name() {
    return "buck.File";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct File

struct FailureSources : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<IndexFailureX>>> {
  static const char* GLEAN_name() {
    return "buck.FailureSources";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct FailureSources

} // namespace Buck

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Buck::FailureReason> {
  using Type = Enum<6>;
};


namespace schema {

namespace Buck {

enum class FailureReason { Skipped, Blocked, EmptyCdb, FailedCdb, QueryFailed, Unclassified };

struct IndexFailureX : Predicate<std::tuple<boost::variant<Alt<0, Fact<Locator>>, Alt<1, Fact<facebook::glean::cpp::schema::Src::File>>>, Fact<IndexerName>, FailureReason, std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>>> {
  static const char* GLEAN_name() {
    return "buck.IndexFailureX";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct IndexFailureX

struct DestinationUses : Predicate<std::tuple<XRefDestination, Fact<facebook::glean::cpp::schema::Src::File>, std::vector<facebook::glean::cpp::schema::Src::ByteSpan>>> {
  static const char* GLEAN_name() {
    return "buck.DestinationUses";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DestinationUses

} // namespace Buck

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Buck::Dependency> {
  using Type = Tuple<facebook::glean::cpp::schema::Buck::Locator, Bool, Bool>;
};


namespace schema {

namespace Buck {

struct Dependency {
  Fact<Locator> target;
  bool explicit_;
  bool exported;

  bool operator==(const Dependency& other) const {
    return std::tie(target,explicit_,exported)
             == std::tie(other.target,other.explicit_,other.exported);
  }
  bool operator!=(const Dependency& other) const {
    return std::tie(target,explicit_,exported)
             != std::tie(other.target,other.explicit_,other.exported);
  }
  bool operator<(const Dependency& other) const {
    return std::tie(target,explicit_,exported)
             < std::tie(other.target,other.explicit_,other.exported);
  }
  bool operator<=(const Dependency& other) const {
    return std::tie(target,explicit_,exported)
             <= std::tie(other.target,other.explicit_,other.exported);
  }
  bool operator>(const Dependency& other) const {
    return std::tie(target,explicit_,exported)
             > std::tie(other.target,other.explicit_,other.exported);
  }
  bool operator>=(const Dependency& other) const {
    return std::tie(target,explicit_,exported)
             >= std::tie(other.target,other.explicit_,other.exported);
  }
  void outputRepr(Output<Repr<Dependency>> out) const {
    outputValue(out, std::make_tuple(target, explicit_, exported));
  }
}; // struct Dependency

struct TargetDependencies : Predicate<std::tuple<Fact<Target>, std::vector<Dependency>>> {
  static const char* GLEAN_name() {
    return "buck.TargetDependencies";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct TargetDependencies

struct DefinitionLocation : Predicate<std::tuple<Fact<Definition>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "buck.DefinitionLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct DefinitionLocation

struct Definition : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::string>> {
  static const char* GLEAN_name() {
    return "buck.Definition";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Definition

struct Consumer : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, Fact<TargetSources>>> {
  static const char* GLEAN_name() {
    return "buck.Consumer";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct Consumer

} // namespace Buck

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Buck::CallName> {
  using Type = Sum<String, facebook::glean::cpp::schema::Buck::Definition>;
};


namespace schema {

namespace Buck {

struct CallName {
  boost::variant<Alt<0, std::string>, Alt<1, Fact<Definition>>> GLEAN_value;

  static CallName prim(const std::string& a) {
    return CallName{Alt<0, std::string>(a)};
  }
  static CallName definition(const Fact<Definition>& a) {
    return CallName{Alt<1, Fact<Definition>>(a)};
  }

  bool operator==(const CallName& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const CallName& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const CallName& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const CallName& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const CallName& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const CallName& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<CallName>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct CallName

struct CallExpr : Predicate<boost::variant<Alt<0, CallName>, Alt<1, std::tuple<Fact<CallExpr>, std::string>>>> {
  static const char* GLEAN_name() {
    return "buck.CallExpr";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CallExpr

struct CallArgument : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>, Fact<ArgumentValue>, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "buck.CallArgument";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CallArgument

struct AttributeName : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "buck.AttributeName";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct AttributeName

} // namespace Buck

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Buck::AttributeMapping> {
  using Type = Tuple<String, facebook::glean::cpp::schema::Buck::AttributeValue>;
};


namespace schema {

namespace Buck {

struct AttributeMapping {
  std::string key;
  Fact<AttributeValue> value;

  bool operator==(const AttributeMapping& other) const {
    return std::tie(key,value)
             == std::tie(other.key,other.value);
  }
  bool operator!=(const AttributeMapping& other) const {
    return std::tie(key,value)
             != std::tie(other.key,other.value);
  }
  bool operator<(const AttributeMapping& other) const {
    return std::tie(key,value)
             < std::tie(other.key,other.value);
  }
  bool operator<=(const AttributeMapping& other) const {
    return std::tie(key,value)
             <= std::tie(other.key,other.value);
  }
  bool operator>(const AttributeMapping& other) const {
    return std::tie(key,value)
             > std::tie(other.key,other.value);
  }
  bool operator>=(const AttributeMapping& other) const {
    return std::tie(key,value)
             >= std::tie(other.key,other.value);
  }
  void outputRepr(Output<Repr<AttributeMapping>> out) const {
    outputValue(out, std::make_tuple(key, value));
  }
}; // struct AttributeMapping

struct AttributeValue : Predicate<boost::variant<Alt<0, std::string>, Alt<1, std::vector<Fact<AttributeValue>>>, Alt<2, std::vector<AttributeMapping>>>> {
  static const char* GLEAN_name() {
    return "buck.AttributeValue";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct AttributeValue

} // namespace Buck

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Buck::ArgumentMapping> {
  using Type = Tuple<String, facebook::glean::cpp::schema::Buck::ArgumentValue>;
};


namespace schema {

namespace Buck {

struct ArgumentMapping {
  std::string key;
  Fact<ArgumentValue> value;

  bool operator==(const ArgumentMapping& other) const {
    return std::tie(key,value)
             == std::tie(other.key,other.value);
  }
  bool operator!=(const ArgumentMapping& other) const {
    return std::tie(key,value)
             != std::tie(other.key,other.value);
  }
  bool operator<(const ArgumentMapping& other) const {
    return std::tie(key,value)
             < std::tie(other.key,other.value);
  }
  bool operator<=(const ArgumentMapping& other) const {
    return std::tie(key,value)
             <= std::tie(other.key,other.value);
  }
  bool operator>(const ArgumentMapping& other) const {
    return std::tie(key,value)
             > std::tie(other.key,other.value);
  }
  bool operator>=(const ArgumentMapping& other) const {
    return std::tie(key,value)
             >= std::tie(other.key,other.value);
  }
  void outputRepr(Output<Repr<ArgumentMapping>> out) const {
    outputValue(out, std::make_tuple(key, value));
  }
}; // struct ArgumentMapping

struct ArgumentValue : Predicate<boost::variant<Alt<0, std::string>, Alt<1, std::vector<Fact<ArgumentValue>>>, Alt<2, std::vector<ArgumentMapping>>>> {
  static const char* GLEAN_name() {
    return "buck.ArgumentValue";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct ArgumentValue

} // namespace Buck

namespace Anglelang {

struct TypeDecl : Predicate<std::tuple<Fact<Name>, Fact<Type>>> {
  static const char* GLEAN_name() {
    return "anglelang.TypeDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TypeDecl

struct Name : Predicate<std::string> {
  static const char* GLEAN_name() {
    return "anglelang.Name";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Name

using ImportStmt = Fact<Name>;

} // namespace Anglelang

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Anglelang::Field> {
  using Type = Tuple<facebook::glean::cpp::schema::Anglelang::Name, facebook::glean::cpp::schema::Anglelang::Type>;
};


namespace schema {

namespace Anglelang {

struct Field {
  Fact<Name> name;
  Fact<Type> ty;

  bool operator==(const Field& other) const {
    return std::tie(name,ty)
             == std::tie(other.name,other.ty);
  }
  bool operator!=(const Field& other) const {
    return std::tie(name,ty)
             != std::tie(other.name,other.ty);
  }
  bool operator<(const Field& other) const {
    return std::tie(name,ty)
             < std::tie(other.name,other.ty);
  }
  bool operator<=(const Field& other) const {
    return std::tie(name,ty)
             <= std::tie(other.name,other.ty);
  }
  bool operator>(const Field& other) const {
    return std::tie(name,ty)
             > std::tie(other.name,other.ty);
  }
  bool operator>=(const Field& other) const {
    return std::tie(name,ty)
             >= std::tie(other.name,other.ty);
  }
  void outputRepr(Output<Repr<Field>> out) const {
    outputValue(out, std::make_tuple(name, ty));
  }
}; // struct Field

struct Type : Predicate<boost::variant<Alt<0, std::tuple<>>, Alt<1, std::tuple<>>, Alt<2, std::tuple<>>, Alt<3, std::tuple<>>, Alt<4, Fact<Type>>, Alt<5, Fact<Type>>, Alt<6, Fact<Type>>, Alt<7, std::vector<Field>>, Alt<8, std::vector<Field>>, Alt<9, Fact<Name>>, Alt<10, Fact<Name>>, Alt<11, std::vector<Fact<Name>>>>> {
  static const char* GLEAN_name() {
    return "anglelang.Type";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct Type

struct EvolveDecl : Predicate<std::tuple<Fact<Name>, Fact<Name>>> {
  static const char* GLEAN_name() {
    return "anglelang.EvolveDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EvolveDecl

} // namespace Anglelang

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Anglelang::DeriveInfo> {
  using Type = Enum<4>;
};


namespace schema {

namespace Anglelang {

enum class DeriveInfo { NoDeriving, OnDemand, Stored, IfEmpty };

struct DerivingDecl : Predicate<std::tuple<Fact<Name>, DeriveInfo>> {
  static const char* GLEAN_name() {
    return "anglelang.DerivingDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DerivingDecl

struct PredicateDecl : Predicate<std::tuple<Fact<Name>, Fact<Type>, Fact<Type>, DeriveInfo>> {
  static const char* GLEAN_name() {
    return "anglelang.PredicateDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct PredicateDecl

} // namespace Anglelang

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Anglelang::Declaration> {
  using Type = Sum<facebook::glean::cpp::schema::Anglelang::PredicateDecl, facebook::glean::cpp::schema::Anglelang::TypeDecl, facebook::glean::cpp::schema::Anglelang::SchemaDecl, Repr<facebook::glean::cpp::schema::Anglelang::ImportStmt>, facebook::glean::cpp::schema::Anglelang::EvolveDecl, facebook::glean::cpp::schema::Anglelang::DerivingDecl>;
};


namespace schema {

namespace Anglelang {

struct Declaration {
  boost::variant<Alt<0, Fact<PredicateDecl>>, Alt<1, Fact<TypeDecl>>, Alt<2, Fact<SchemaDecl>>, Alt<3, ImportStmt>, Alt<4, Fact<EvolveDecl>>, Alt<5, Fact<DerivingDecl>>> GLEAN_value;

  static Declaration pred(const Fact<PredicateDecl>& a) {
    return Declaration{Alt<0, Fact<PredicateDecl>>(a)};
  }
  static Declaration ty(const Fact<TypeDecl>& a) {
    return Declaration{Alt<1, Fact<TypeDecl>>(a)};
  }
  static Declaration schema(const Fact<SchemaDecl>& a) {
    return Declaration{Alt<2, Fact<SchemaDecl>>(a)};
  }
  static Declaration imp(const ImportStmt& a) {
    return Declaration{Alt<3, ImportStmt>(a)};
  }
  static Declaration evolve(const Fact<EvolveDecl>& a) {
    return Declaration{Alt<4, Fact<EvolveDecl>>(a)};
  }
  static Declaration derive_(const Fact<DerivingDecl>& a) {
    return Declaration{Alt<5, Fact<DerivingDecl>>(a)};
  }

  bool operator==(const Declaration& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Declaration& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Declaration& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Declaration& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Declaration>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Declaration

struct DeclarationLocation : Predicate<std::tuple<Declaration, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "anglelang.DeclarationLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationLocation

struct DeclarationToName : Predicate<Declaration, Fact<Name>> {
  static const char* GLEAN_name() {
    return "anglelang.DeclarationToName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct DeclarationToName

struct SchemaDecl : Predicate<std::tuple<Fact<Name>, std::vector<Declaration>>> {
  static const char* GLEAN_name() {
    return "anglelang.SchemaDecl";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SchemaDecl

} // namespace Anglelang

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Anglelang::XRefTarget> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Anglelang::Declaration>>;
};


namespace schema {

namespace Anglelang {

struct XRefTarget {
  Declaration ref;

  bool operator==(const XRefTarget& other) const {
    return std::tie(ref)
             == std::tie(other.ref);
  }
  bool operator!=(const XRefTarget& other) const {
    return std::tie(ref)
             != std::tie(other.ref);
  }
  bool operator<(const XRefTarget& other) const {
    return std::tie(ref)
             < std::tie(other.ref);
  }
  bool operator<=(const XRefTarget& other) const {
    return std::tie(ref)
             <= std::tie(other.ref);
  }
  bool operator>(const XRefTarget& other) const {
    return std::tie(ref)
             > std::tie(other.ref);
  }
  bool operator>=(const XRefTarget& other) const {
    return std::tie(ref)
             >= std::tie(other.ref);
  }
  void outputRepr(Output<Repr<XRefTarget>> out) const {
    outputValue(out, std::make_tuple(ref));
  }
}; // struct XRefTarget

struct TargetUses : Predicate<std::tuple<XRefTarget, Fact<facebook::glean::cpp::schema::Src::File>, std::vector<facebook::glean::cpp::schema::Src::ByteSpan>>> {
  static const char* GLEAN_name() {
    return "anglelang.TargetUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct TargetUses

} // namespace Anglelang

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Anglelang::XRef> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Anglelang::XRefTarget>, Array<Repr<facebook::glean::cpp::schema::Src::ByteSpan>>>;
};


namespace schema {

namespace Anglelang {

struct XRef {
  XRefTarget target;
  std::vector<facebook::glean::cpp::schema::Src::ByteSpan> span;

  bool operator==(const XRef& other) const {
    return std::tie(target,span)
             == std::tie(other.target,other.span);
  }
  bool operator!=(const XRef& other) const {
    return std::tie(target,span)
             != std::tie(other.target,other.span);
  }
  bool operator<(const XRef& other) const {
    return std::tie(target,span)
             < std::tie(other.target,other.span);
  }
  bool operator<=(const XRef& other) const {
    return std::tie(target,span)
             <= std::tie(other.target,other.span);
  }
  bool operator>(const XRef& other) const {
    return std::tie(target,span)
             > std::tie(other.target,other.span);
  }
  bool operator>=(const XRef& other) const {
    return std::tie(target,span)
             >= std::tie(other.target,other.span);
  }
  void outputRepr(Output<Repr<XRef>> out) const {
    outputValue(out, std::make_tuple(target, span));
  }
}; // struct XRef

struct FileXRefs : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, std::vector<XRef>>> {
  static const char* GLEAN_name() {
    return "anglelang.FileXRefs";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct FileXRefs

} // namespace Anglelang

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Anglelang::Entity> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Anglelang::Declaration>>;
};


namespace schema {

namespace Code {

namespace Anglelang {

struct Entity {
  facebook::glean::cpp::schema::Anglelang::Declaration decl;

  bool operator==(const Entity& other) const {
    return std::tie(decl)
             == std::tie(other.decl);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(decl)
             != std::tie(other.decl);
  }
  bool operator<(const Entity& other) const {
    return std::tie(decl)
             < std::tie(other.decl);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(decl)
             <= std::tie(other.decl);
  }
  bool operator>(const Entity& other) const {
    return std::tie(decl)
             > std::tie(other.decl);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(decl)
             >= std::tie(other.decl);
  }
  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, std::make_tuple(decl));
  }
}; // struct Entity

} // namespace Anglelang

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Entity> {
  using Type = Sum<Repr<facebook::glean::cpp::schema::Code::Cxx::Entity>, Repr<facebook::glean::cpp::schema::Code::Pp::Entity>, Repr<facebook::glean::cpp::schema::Code::Java::Entity>, Repr<facebook::glean::cpp::schema::Code::Kotlin::Entity>, Repr<facebook::glean::cpp::schema::Code::Hs::Entity>, Repr<facebook::glean::cpp::schema::Code::Python::Entity>, Repr<facebook::glean::cpp::schema::Code::Hack::Entity>, Repr<facebook::glean::cpp::schema::Code::Flow::Entity>, Repr<facebook::glean::cpp::schema::Code::Fbthrift::Entity>, Repr<facebook::glean::cpp::schema::Code::Buck::Entity>, Repr<facebook::glean::cpp::schema::Code::Erlang::Entity>, Repr<facebook::glean::cpp::schema::Code::Lsif::Entity>, Repr<facebook::glean::cpp::schema::Code::Scip::Entity>, Repr<facebook::glean::cpp::schema::Code::Csharp::Entity>, Repr<facebook::glean::cpp::schema::Code::Graphql::Entity>, Repr<facebook::glean::cpp::schema::Code::Dataswarm::Entity>, Repr<facebook::glean::cpp::schema::Code::Anglelang::Entity>>;
};


namespace schema {

namespace Code {

struct Entity {
  boost::variant<Alt<0, facebook::glean::cpp::schema::Code::Cxx::Entity>, Alt<1, facebook::glean::cpp::schema::Code::Pp::Entity>, Alt<2, facebook::glean::cpp::schema::Code::Java::Entity>, Alt<3, facebook::glean::cpp::schema::Code::Kotlin::Entity>, Alt<4, facebook::glean::cpp::schema::Code::Hs::Entity>, Alt<5, facebook::glean::cpp::schema::Code::Python::Entity>, Alt<6, facebook::glean::cpp::schema::Code::Hack::Entity>, Alt<7, facebook::glean::cpp::schema::Code::Flow::Entity>, Alt<8, facebook::glean::cpp::schema::Code::Fbthrift::Entity>, Alt<9, facebook::glean::cpp::schema::Code::Buck::Entity>, Alt<10, facebook::glean::cpp::schema::Code::Erlang::Entity>, Alt<11, facebook::glean::cpp::schema::Code::Lsif::Entity>, Alt<12, facebook::glean::cpp::schema::Code::Scip::Entity>, Alt<13, facebook::glean::cpp::schema::Code::Csharp::Entity>, Alt<14, facebook::glean::cpp::schema::Code::Graphql::Entity>, Alt<15, facebook::glean::cpp::schema::Code::Dataswarm::Entity>, Alt<16, facebook::glean::cpp::schema::Code::Anglelang::Entity>> GLEAN_value;

  static Entity cxx(const facebook::glean::cpp::schema::Code::Cxx::Entity& a) {
    return Entity{Alt<0, facebook::glean::cpp::schema::Code::Cxx::Entity>(a)};
  }
  static Entity pp(const facebook::glean::cpp::schema::Code::Pp::Entity& a) {
    return Entity{Alt<1, facebook::glean::cpp::schema::Code::Pp::Entity>(a)};
  }
  static Entity java(const facebook::glean::cpp::schema::Code::Java::Entity& a) {
    return Entity{Alt<2, facebook::glean::cpp::schema::Code::Java::Entity>(a)};
  }
  static Entity kotlin(const facebook::glean::cpp::schema::Code::Kotlin::Entity& a) {
    return Entity{Alt<3, facebook::glean::cpp::schema::Code::Kotlin::Entity>(a)};
  }
  static Entity hs(const facebook::glean::cpp::schema::Code::Hs::Entity& a) {
    return Entity{Alt<4, facebook::glean::cpp::schema::Code::Hs::Entity>(a)};
  }
  static Entity python(const facebook::glean::cpp::schema::Code::Python::Entity& a) {
    return Entity{Alt<5, facebook::glean::cpp::schema::Code::Python::Entity>(a)};
  }
  static Entity hack(const facebook::glean::cpp::schema::Code::Hack::Entity& a) {
    return Entity{Alt<6, facebook::glean::cpp::schema::Code::Hack::Entity>(a)};
  }
  static Entity flow(const facebook::glean::cpp::schema::Code::Flow::Entity& a) {
    return Entity{Alt<7, facebook::glean::cpp::schema::Code::Flow::Entity>(a)};
  }
  static Entity fbthrift(const facebook::glean::cpp::schema::Code::Fbthrift::Entity& a) {
    return Entity{Alt<8, facebook::glean::cpp::schema::Code::Fbthrift::Entity>(a)};
  }
  static Entity buck(const facebook::glean::cpp::schema::Code::Buck::Entity& a) {
    return Entity{Alt<9, facebook::glean::cpp::schema::Code::Buck::Entity>(a)};
  }
  static Entity erlang(const facebook::glean::cpp::schema::Code::Erlang::Entity& a) {
    return Entity{Alt<10, facebook::glean::cpp::schema::Code::Erlang::Entity>(a)};
  }
  static Entity lsif(const facebook::glean::cpp::schema::Code::Lsif::Entity& a) {
    return Entity{Alt<11, facebook::glean::cpp::schema::Code::Lsif::Entity>(a)};
  }
  static Entity scip(const facebook::glean::cpp::schema::Code::Scip::Entity& a) {
    return Entity{Alt<12, facebook::glean::cpp::schema::Code::Scip::Entity>(a)};
  }
  static Entity csharp(const facebook::glean::cpp::schema::Code::Csharp::Entity& a) {
    return Entity{Alt<13, facebook::glean::cpp::schema::Code::Csharp::Entity>(a)};
  }
  static Entity graphql(const facebook::glean::cpp::schema::Code::Graphql::Entity& a) {
    return Entity{Alt<14, facebook::glean::cpp::schema::Code::Graphql::Entity>(a)};
  }
  static Entity dataswarm(const facebook::glean::cpp::schema::Code::Dataswarm::Entity& a) {
    return Entity{Alt<15, facebook::glean::cpp::schema::Code::Dataswarm::Entity>(a)};
  }
  static Entity angle(const facebook::glean::cpp::schema::Code::Anglelang::Entity& a) {
    return Entity{Alt<16, facebook::glean::cpp::schema::Code::Anglelang::Entity>(a)};
  }

  bool operator==(const Entity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Entity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Entity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Entity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Entity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Entity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Entity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Entity

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::Argument> {
  using Type = Sum<String, Repr<facebook::glean::cpp::schema::Code::Entity>>;
};


namespace schema {

namespace Code {

struct Argument {
  boost::variant<Alt<0, std::string>, Alt<1, Entity>> GLEAN_value;

  static Argument lit(const std::string& a) {
    return Argument{Alt<0, std::string>(a)};
  }
  static Argument xref(const Entity& a) {
    return Argument{Alt<1, Entity>(a)};
  }

  bool operator==(const Argument& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const Argument& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const Argument& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const Argument& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const Argument& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const Argument& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<Argument>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct Argument

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::CallArgument> {
  using Type = Tuple<Maybe<String>, Repr<facebook::glean::cpp::schema::Src::ByteSpan>, Maybe<Repr<facebook::glean::cpp::schema::Code::Argument>>>;
};


namespace schema {

namespace Code {

struct CallArgument {
  boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>> label;
  facebook::glean::cpp::schema::Src::ByteSpan span;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Argument>> argument;

  bool operator==(const CallArgument& other) const {
    return std::tie(label,span,argument)
             == std::tie(other.label,other.span,other.argument);
  }
  bool operator!=(const CallArgument& other) const {
    return std::tie(label,span,argument)
             != std::tie(other.label,other.span,other.argument);
  }
  bool operator<(const CallArgument& other) const {
    return std::tie(label,span,argument)
             < std::tie(other.label,other.span,other.argument);
  }
  bool operator<=(const CallArgument& other) const {
    return std::tie(label,span,argument)
             <= std::tie(other.label,other.span,other.argument);
  }
  bool operator>(const CallArgument& other) const {
    return std::tie(label,span,argument)
             > std::tie(other.label,other.span,other.argument);
  }
  bool operator>=(const CallArgument& other) const {
    return std::tie(label,span,argument)
             >= std::tie(other.label,other.span,other.argument);
  }
  void outputRepr(Output<Repr<CallArgument>> out) const {
    outputValue(out, std::make_tuple(label, span, argument));
  }
}; // struct CallArgument

} // namespace Code

namespace Codemarkup {

namespace Hack {

struct ConvertCallArguments : Predicate<std::tuple<std::vector<facebook::glean::cpp::schema::Hack::CallArgument>, std::vector<facebook::glean::cpp::schema::Code::CallArgument>>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.ConvertCallArguments";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ConvertCallArguments

struct ConvertMaybeCallArguments : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Hack::CallArgument>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::CallArgument>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.ConvertMaybeCallArguments";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ConvertMaybeCallArguments

} // namespace Hack

namespace Python {

struct ConvertCallArguments : Predicate<std::tuple<std::vector<facebook::glean::cpp::schema::Python::CallArgument>, std::vector<facebook::glean::cpp::schema::Code::CallArgument>>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.ConvertCallArguments";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ConvertCallArguments

struct PythonFileCall : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, std::vector<facebook::glean::cpp::schema::Code::CallArgument>>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.PythonFileCall";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct PythonFileCall

} // namespace Python

namespace Hack {

struct ConvertArgument : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Hack::Argument>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::Argument>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.ConvertArgument";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ConvertArgument

} // namespace Hack

namespace Python {

struct ConvertArgument : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Python::Argument>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::Argument>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.python.ConvertArgument";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ConvertArgument

} // namespace Python

} // namespace Codemarkup

namespace Code {

struct EntityLanguage : Predicate<std::tuple<Entity, Language>> {
  static const char* GLEAN_name() {
    return "code.EntityLanguage";
  }

  static constexpr size_t GLEAN_version() {
     return 24;
  }
}; // struct EntityLanguage

} // namespace Code

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Code::IdlEntity> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Code::Language>, facebook::glean::cpp::schema::Src::File, Maybe<Repr<facebook::glean::cpp::schema::Code::Entity>>, Maybe<Repr<facebook::glean::cpp::schema::Src::Range>>>;
};


namespace schema {

namespace Code {

struct IdlEntity {
  Language lang;
  Fact<facebook::glean::cpp::schema::Src::File> file;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, Entity>> entity;
  boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Src::Range>> range;

  bool operator==(const IdlEntity& other) const {
    return std::tie(lang,file,entity,range)
             == std::tie(other.lang,other.file,other.entity,other.range);
  }
  bool operator!=(const IdlEntity& other) const {
    return std::tie(lang,file,entity,range)
             != std::tie(other.lang,other.file,other.entity,other.range);
  }
  bool operator<(const IdlEntity& other) const {
    return std::tie(lang,file,entity,range)
             < std::tie(other.lang,other.file,other.entity,other.range);
  }
  bool operator<=(const IdlEntity& other) const {
    return std::tie(lang,file,entity,range)
             <= std::tie(other.lang,other.file,other.entity,other.range);
  }
  bool operator>(const IdlEntity& other) const {
    return std::tie(lang,file,entity,range)
             > std::tie(other.lang,other.file,other.entity,other.range);
  }
  bool operator>=(const IdlEntity& other) const {
    return std::tie(lang,file,entity,range)
             >= std::tie(other.lang,other.file,other.entity,other.range);
  }
  void outputRepr(Output<Repr<IdlEntity>> out) const {
    outputValue(out, std::make_tuple(lang, file, entity, range));
  }
}; // struct IdlEntity

} // namespace Code

namespace Codemarkup {

namespace Cxx {

struct CxxEntityIdl : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Cxx::Entity, facebook::glean::cpp::schema::Code::IdlEntity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxEntityIdl";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxEntityIdl

} // namespace Cxx

namespace Hack {

struct HackEntityIdl : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Hack::Entity, facebook::glean::cpp::schema::Code::IdlEntity>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackEntityIdl";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackEntityIdl

} // namespace Hack

namespace Yaml {

struct YamlFileEntityXLangXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan, facebook::glean::cpp::schema::Code::IdlEntity>> {
  static const char* GLEAN_name() {
    return "codemarkup.yaml.YamlFileEntityXLangXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct YamlFileEntityXLangXRefLocations

} // namespace Yaml

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::ChildEntity> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Code::Entity>, Repr<facebook::glean::cpp::schema::Codemarkup::Types::Location>>;
};


namespace schema {

namespace Codemarkup {

struct ChildEntity {
  facebook::glean::cpp::schema::Code::Entity child;
  facebook::glean::cpp::schema::Codemarkup::Types::Location location;

  bool operator==(const ChildEntity& other) const {
    return std::tie(child,location)
             == std::tie(other.child,other.location);
  }
  bool operator!=(const ChildEntity& other) const {
    return std::tie(child,location)
             != std::tie(other.child,other.location);
  }
  bool operator<(const ChildEntity& other) const {
    return std::tie(child,location)
             < std::tie(other.child,other.location);
  }
  bool operator<=(const ChildEntity& other) const {
    return std::tie(child,location)
             <= std::tie(other.child,other.location);
  }
  bool operator>(const ChildEntity& other) const {
    return std::tie(child,location)
             > std::tie(other.child,other.location);
  }
  bool operator>=(const ChildEntity& other) const {
    return std::tie(child,location)
             >= std::tie(other.child,other.location);
  }
  void outputRepr(Output<Repr<ChildEntity>> out) const {
    outputValue(out, std::make_tuple(child, location));
  }
}; // struct ChildEntity

struct ContainsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.ContainsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct ContainsChildEntity

struct ContainsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.ContainsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct ContainsParentEntity

struct EntityComments : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, boost::variant<Alt<0, std::tuple<>>, Alt<1, std::string>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityComments";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityComments

struct EntityInfo : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityInfo";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityInfo

struct EntityIsDefinition : Predicate<facebook::glean::cpp::schema::Code::Entity> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityIsDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityIsDefinition

struct EntityKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityKind";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityKind

struct EntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityLocation

struct EntityModifiers : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Modifiers>> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityModifiers";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityModifiers

struct EntityModuleName : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, std::string>> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityModuleName";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityModuleName

struct EntityReferences : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityReferences";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityReferences

struct EntitySource : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.EntitySource";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntitySource

struct EntityToAnnotations : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Code::Annotations>> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityToAnnotations";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityToAnnotations

struct EntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityUses

struct EntityVisibility : Predicate<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Visibility> {
  static const char* GLEAN_name() {
    return "codemarkup.EntityVisibility";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct EntityVisibility

struct ExtendsChildEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.ExtendsChildEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct ExtendsChildEntity

struct ExtendsParentEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.ExtendsParentEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct ExtendsParentEntity

struct ExtendsParentEntityConcise : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.ExtendsParentEntityConcise";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct ExtendsParentEntityConcise

struct FileCall : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, std::vector<facebook::glean::cpp::schema::Code::CallArgument>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::Entity>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::CallArgument>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::Entity>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.FileCall";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct FileCall

struct FileEntityDigest : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Code::Entity>, std::string> {
  static const char* GLEAN_name() {
    return "codemarkup.FileEntityDigest";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct FileEntityDigest

struct FileEntityInfos : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.FileEntityInfos";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct FileEntityInfos

struct FileEntityKinds : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.FileEntityKinds";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct FileEntityKinds

struct FileEntityLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.FileEntityLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct FileEntityLocations

struct FileEntityXRefInfos : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolInfo>> {
  static const char* GLEAN_name() {
    return "codemarkup.FileEntityXRefInfos";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct FileEntityXRefInfos

struct FileEntityXRefKinds : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>> {
  static const char* GLEAN_name() {
    return "codemarkup.FileEntityXRefKinds";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct FileEntityXRefKinds

struct FileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.FileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct FileEntityXRefLocations

struct FileEntityXRefRangeSpans : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.FileEntityXRefRangeSpans";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct FileEntityXRefRangeSpans

struct FindEntityDefinition : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.FindEntityDefinition";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct FindEntityDefinition

struct GeneratedEntityToIdlEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Code::IdlEntity>> {
  static const char* GLEAN_name() {
    return "codemarkup.GeneratedEntityToIdlEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct GeneratedEntityToIdlEntity

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::GenericEntity> {
  using Type = Sum<Tuple<Repr<facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation>, Repr<facebook::glean::cpp::schema::Code::Entity>>, Tuple<Repr<facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan>, Repr<facebook::glean::cpp::schema::Code::IdlEntity>>, Tuple<Repr<facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan>, Repr<facebook::glean::cpp::schema::Code::SymbolId>>>;
};


namespace schema {

namespace Codemarkup {

struct GenericEntity {
  boost::variant<Alt<0, std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Entity>>, Alt<1, std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan, facebook::glean::cpp::schema::Code::IdlEntity>>, Alt<2, std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan, facebook::glean::cpp::schema::Code::SymbolId>>> GLEAN_value;

  static GenericEntity plainEntity(const facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation& xref, const facebook::glean::cpp::schema::Code::Entity& entity) {
    return GenericEntity{Alt<0, std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Entity>>(std::make_tuple(xref, entity))};
  }
  static GenericEntity xlangEntity(const facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan& source, const facebook::glean::cpp::schema::Code::IdlEntity& entity) {
    return GenericEntity{Alt<1, std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan, facebook::glean::cpp::schema::Code::IdlEntity>>(std::make_tuple(source, entity))};
  }
  static GenericEntity xlangSymbol(const facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan& source, const facebook::glean::cpp::schema::Code::SymbolId& symbol) {
    return GenericEntity{Alt<2, std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan, facebook::glean::cpp::schema::Code::SymbolId>>(std::make_tuple(source, symbol))};
  }

  bool operator==(const GenericEntity& other) const {
    return std::tie(GLEAN_value)
             == std::tie(other.GLEAN_value);
  }
  bool operator!=(const GenericEntity& other) const {
    return std::tie(GLEAN_value)
             != std::tie(other.GLEAN_value);
  }
  bool operator<(const GenericEntity& other) const {
    return std::tie(GLEAN_value)
             < std::tie(other.GLEAN_value);
  }
  bool operator<=(const GenericEntity& other) const {
    return std::tie(GLEAN_value)
             <= std::tie(other.GLEAN_value);
  }
  bool operator>(const GenericEntity& other) const {
    return std::tie(GLEAN_value)
             > std::tie(other.GLEAN_value);
  }
  bool operator>=(const GenericEntity& other) const {
    return std::tie(GLEAN_value)
             >= std::tie(other.GLEAN_value);
  }

  void outputRepr(Output<Repr<GenericEntity>> out) const {
    outputValue(out, GLEAN_value);
  }
}; // struct GenericEntity

struct FileXRefsGenericEntities : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, GenericEntity>> {
  static const char* GLEAN_name() {
    return "codemarkup.FileXRefsGenericEntities";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct FileXRefsGenericEntities

} // namespace Codemarkup

} // namespace schema

template<> struct Repr_<facebook::glean::cpp::schema::Codemarkup::ParentEntity> {
  using Type = Tuple<Repr<facebook::glean::cpp::schema::Code::Entity>, Repr<facebook::glean::cpp::schema::Codemarkup::Types::Location>>;
};


namespace schema {

namespace Codemarkup {

struct ParentEntity {
  facebook::glean::cpp::schema::Code::Entity parent;
  facebook::glean::cpp::schema::Codemarkup::Types::Location location;

  bool operator==(const ParentEntity& other) const {
    return std::tie(parent,location)
             == std::tie(other.parent,other.location);
  }
  bool operator!=(const ParentEntity& other) const {
    return std::tie(parent,location)
             != std::tie(other.parent,other.location);
  }
  bool operator<(const ParentEntity& other) const {
    return std::tie(parent,location)
             < std::tie(other.parent,other.location);
  }
  bool operator<=(const ParentEntity& other) const {
    return std::tie(parent,location)
             <= std::tie(other.parent,other.location);
  }
  bool operator>(const ParentEntity& other) const {
    return std::tie(parent,location)
             > std::tie(other.parent,other.location);
  }
  bool operator>=(const ParentEntity& other) const {
    return std::tie(parent,location)
             >= std::tie(other.parent,other.location);
  }
  void outputRepr(Output<Repr<ParentEntity>> out) const {
    outputValue(out, std::make_tuple(parent, location));
  }
}; // struct ParentEntity

struct SearchRelatedEntities : Predicate<std::tuple<RelationType, ParentEntity, ChildEntity, SearchStyle>> {
  static const char* GLEAN_name() {
    return "codemarkup.SearchRelatedEntities";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct SearchRelatedEntities

struct ReferencingEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Code::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::RangeSpan, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.ReferencingEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct ReferencingEntity

struct ResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.ResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct ResolveLocation

struct SearchInheritedEntities : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, ParentEntity, ChildEntity, SearchStyle>> {
  static const char* GLEAN_name() {
    return "codemarkup.SearchInheritedEntities";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct SearchInheritedEntities

struct SymbolToEntity : Predicate<std::tuple<facebook::glean::cpp::schema::Code::SymbolId, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.SymbolToEntity";
  }

  static constexpr size_t GLEAN_version() {
     return 30;
  }
}; // struct SymbolToEntity

namespace Cxx {

struct CxxFileEntityIdl : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Cxx1::FileXRefs>, facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Code::IdlEntity>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxFileEntityIdl";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxFileEntityIdl

struct CxxIdlEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.cxx.CxxIdlEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 4;
  }
}; // struct CxxIdlEntityUses

} // namespace Cxx

namespace Hack {

struct ConvertCallee : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Hack::XRefTarget>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::Entity>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.ConvertCallee";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ConvertCallee

struct ConvertCalleeForFileCall : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Hack::XRefTarget>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::Entity>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.ConvertCalleeForFileCall";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ConvertCalleeForFileCall

struct ConvertStaticType : Predicate<std::tuple<boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Hack::Declaration>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::Entity>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.ConvertStaticType";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct ConvertStaticType

struct HackFileCall : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan, std::vector<facebook::glean::cpp::schema::Code::CallArgument>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::Entity>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::CallArgument>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Code::Entity>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackFileCall";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackFileCall

struct HackIdlEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.hack.HackIdlEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 2;
  }
}; // struct HackIdlEntityUses

} // namespace Hack

namespace Search {

struct EntityLocationAndKind : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>>> {
  static const char* GLEAN_name() {
    return "codemarkup.search.EntityLocationAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct EntityLocationAndKind

struct SearchByName : Predicate<std::tuple<SearchCase, std::string, facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Language>> {
  static const char* GLEAN_name() {
    return "codemarkup.search.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchByName

struct SearchByScope : Predicate<std::tuple<SearchCase, std::string, std::vector<std::string>, facebook::glean::cpp::schema::Code::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Language>> {
  static const char* GLEAN_name() {
    return "codemarkup.search.SearchByScope";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchByScope

} // namespace Search

} // namespace Codemarkup

namespace Dyn {

struct EntityUsage : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Entity, Observer, Usage, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<Environment>>>>> {
  static const char* GLEAN_name() {
    return "dyn.EntityUsage";
  }

  static constexpr size_t GLEAN_version() {
     return 6;
  }
}; // struct EntityUsage

} // namespace Dyn

namespace Search {

namespace Code {

struct AngleSearchByLowerCaseName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.AngleSearchByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct AngleSearchByLowerCaseName

struct AngleSearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.AngleSearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct AngleSearchByName

struct BuckSearchByLocalNameFact : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Buck::LocalName>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.BuckSearchByLocalNameFact";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct BuckSearchByLocalNameFact

struct BuckSearchByLowerCaseName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.BuckSearchByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct BuckSearchByLowerCaseName

struct BuckSearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.BuckSearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct BuckSearchByName

struct CSharpSearchByLowerCaseName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.CSharpSearchByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct CSharpSearchByLowerCaseName

struct CSharpSearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.CSharpSearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct CSharpSearchByName

struct CxxSearchByLowerCaseNameKindAndScopeFact : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Cxx1::Scope, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.CxxSearchByLowerCaseNameKindAndScopeFact";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct CxxSearchByLowerCaseNameKindAndScopeFact

struct CxxSearchByLowerCaseScopeAndKind : Predicate<std::tuple<std::string, std::vector<std::string>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.CxxSearchByLowerCaseScopeAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct CxxSearchByLowerCaseScopeAndKind

struct CxxSearchByNameKindAndScopeFact : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Cxx1::Scope, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.CxxSearchByNameKindAndScopeFact";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct CxxSearchByNameKindAndScopeFact

struct CxxSearchByScopeAndKind : Predicate<std::tuple<std::string, std::vector<std::string>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.CxxSearchByScopeAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct CxxSearchByScopeAndKind

struct ErlangSearchByLowerCaseName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.ErlangSearchByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct ErlangSearchByLowerCaseName

struct ErlangSearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.ErlangSearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct ErlangSearchByName

struct FbthriftSearchByNameFact : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Fbthrift::Identifier>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.FbthriftSearchByNameFact";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct FbthriftSearchByNameFact

struct FlowSearchByLowerCaseNameKindAndScopeFact : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Flow::Module>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.FlowSearchByLowerCaseNameKindAndScopeFact";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct FlowSearchByLowerCaseNameKindAndScopeFact

struct FlowSearchByLowerCaseScopeAndKind : Predicate<std::tuple<std::string, std::vector<std::string>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.FlowSearchByLowerCaseScopeAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct FlowSearchByLowerCaseScopeAndKind

struct FlowSearchByNameKindAndScopeFact : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Flow::Module>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.FlowSearchByNameKindAndScopeFact";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct FlowSearchByNameKindAndScopeFact

struct FlowSearchByScopeAndKind : Predicate<std::tuple<std::string, std::vector<std::string>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.FlowSearchByScopeAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct FlowSearchByScopeAndKind

struct GraphQLSearchByLowerCaseName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.GraphQLSearchByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct GraphQLSearchByLowerCaseName

struct GraphQLSearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.GraphQLSearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct GraphQLSearchByName

struct HackSearchByLowerCaseNameAndKind : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.HackSearchByLowerCaseNameAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct HackSearchByLowerCaseNameAndKind

struct HackSearchByLowerCaseScopeAndKind : Predicate<std::tuple<std::string, std::vector<std::string>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.HackSearchByLowerCaseScopeAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct HackSearchByLowerCaseScopeAndKind

struct HackSearchByNameAndKind : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.HackSearchByNameAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct HackSearchByNameAndKind

struct HackSearchByNameKindWithNamespace : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.HackSearchByNameKindWithNamespace";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct HackSearchByNameKindWithNamespace

struct HackSearchByNameKindWithQName : Predicate<std::tuple<std::string, Fact<facebook::glean::cpp::schema::Hack::Name>, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Hack::NamespaceQName>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.HackSearchByNameKindWithQName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct HackSearchByNameKindWithQName

struct HackSearchByScopeAndKind : Predicate<std::tuple<std::string, std::vector<std::string>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.HackSearchByScopeAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct HackSearchByScopeAndKind

struct HackSearchByScopeWithNameKinds : Predicate<std::tuple<std::string, bool, std::vector<std::string>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.HackSearchByScopeWithNameKinds";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct HackSearchByScopeWithNameKinds

struct HsSearchByLowerCaseName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.HsSearchByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct HsSearchByLowerCaseName

struct HsSearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.HsSearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct HsSearchByName

struct JavaSearchByLowerCaseName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.JavaSearchByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct JavaSearchByLowerCaseName

struct JavaSearchByLowerCaseScope : Predicate<std::tuple<std::string, std::vector<std::string>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.JavaSearchByLowerCaseScope";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct JavaSearchByLowerCaseScope

struct JavaSearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.JavaSearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct JavaSearchByName

struct JavaSearchByNameWithFact : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.JavaSearchByNameWithFact";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct JavaSearchByNameWithFact

struct JavaSearchByScope : Predicate<std::tuple<std::string, std::vector<std::string>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.JavaSearchByScope";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct JavaSearchByScope

struct JavaSearchByScopeWithName : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Name>, bool, std::vector<std::string>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.JavaSearchByScopeWithName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct JavaSearchByScopeWithName

struct KotlinSearchByLowerCaseName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.KotlinSearchByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct KotlinSearchByLowerCaseName

struct KotlinSearchByLowerCaseScope : Predicate<std::tuple<std::string, std::vector<std::string>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.KotlinSearchByLowerCaseScope";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct KotlinSearchByLowerCaseScope

struct KotlinSearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.KotlinSearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct KotlinSearchByName

struct KotlinSearchByNameWithFact : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::QName>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.KotlinSearchByNameWithFact";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct KotlinSearchByNameWithFact

struct KotlinSearchByScope : Predicate<std::tuple<std::string, std::vector<std::string>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.KotlinSearchByScope";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct KotlinSearchByScope

struct KotlinSearchByScopeWithName : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Javakotlin::Alpha::Name>, bool, std::vector<std::string>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.KotlinSearchByScopeWithName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct KotlinSearchByScopeWithName

struct LsifSearchByLowerCaseName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.LsifSearchByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct LsifSearchByLowerCaseName

struct LsifSearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.LsifSearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct LsifSearchByName

struct PpSearchByLowerCaseNameKind : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.PpSearchByLowerCaseNameKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct PpSearchByLowerCaseNameKind

struct PpSearchByNameKind : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.PpSearchByNameKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct PpSearchByNameKind

struct PythonSearchByLowerCaseNameKindAndScopeFact : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Python::SName>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.PythonSearchByLowerCaseNameKindAndScopeFact";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct PythonSearchByLowerCaseNameKindAndScopeFact

struct PythonSearchByLowerCaseScopeAndKind : Predicate<std::tuple<std::string, std::vector<std::string>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.PythonSearchByLowerCaseScopeAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct PythonSearchByLowerCaseScopeAndKind

struct PythonSearchByNameKindAndScopeFact : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, Fact<facebook::glean::cpp::schema::Python::SName>>>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.PythonSearchByNameKindAndScopeFact";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct PythonSearchByNameKindAndScopeFact

struct PythonSearchByScopeAndKind : Predicate<std::tuple<std::string, std::vector<std::string>, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.PythonSearchByScopeAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct PythonSearchByScopeAndKind

struct RustSearchByNameAndKind : Predicate<std::tuple<std::string, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.RustSearchByNameAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct RustSearchByNameAndKind

struct SearchByLowerCaseNameAndLanguage : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Language, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.SearchByLowerCaseNameAndLanguage";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct SearchByLowerCaseNameAndLanguage

struct SearchByLowerCaseNameKindAndLanguage : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Language, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.SearchByLowerCaseNameKindAndLanguage";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct SearchByLowerCaseNameKindAndLanguage

struct SearchByLowerCaseScope : Predicate<std::tuple<std::string, std::vector<std::string>, facebook::glean::cpp::schema::Code::Language, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.SearchByLowerCaseScope";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct SearchByLowerCaseScope

struct SearchByLowerCaseScopeAndKind : Predicate<std::tuple<std::string, std::vector<std::string>, facebook::glean::cpp::schema::Code::Language, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.SearchByLowerCaseScopeAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct SearchByLowerCaseScopeAndKind

struct SearchByNameAndLanguage : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Language, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.SearchByNameAndLanguage";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct SearchByNameAndLanguage

struct SearchByNameKindAndLanguage : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Language, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.SearchByNameKindAndLanguage";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct SearchByNameKindAndLanguage

struct SearchByScope : Predicate<std::tuple<std::string, std::vector<std::string>, facebook::glean::cpp::schema::Code::Language, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.SearchByScope";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct SearchByScope

struct SearchByScopeAndKind : Predicate<std::tuple<std::string, std::vector<std::string>, facebook::glean::cpp::schema::Code::Language, boost::variant<Alt<0, std::tuple<>>, Alt<1, facebook::glean::cpp::schema::Codemarkup::Types::SymbolKind>>, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.SearchByScopeAndKind";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct SearchByScopeAndKind

struct ThriftSearchByLowerCaseName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.ThriftSearchByLowerCaseName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct ThriftSearchByLowerCaseName

struct ThriftSearchByName : Predicate<std::tuple<std::string, facebook::glean::cpp::schema::Code::Entity>> {
  static const char* GLEAN_name() {
    return "search.code.ThriftSearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 16;
  }
}; // struct ThriftSearchByName

} // namespace Code

} // namespace Search

namespace Codemarkup {

namespace Anglelang {

struct AngleEntityLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Anglelang::Entity, facebook::glean::cpp::schema::Codemarkup::Types::Location>> {
  static const char* GLEAN_name() {
    return "codemarkup.anglelang.AngleEntityLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct AngleEntityLocation

struct AngleEntityUses : Predicate<std::tuple<facebook::glean::cpp::schema::Code::Anglelang::Entity, Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Src::ByteSpan>> {
  static const char* GLEAN_name() {
    return "codemarkup.anglelang.AngleEntityUses";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct AngleEntityUses

struct AngleFileEntityXRefLocations : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Src::File>, facebook::glean::cpp::schema::Codemarkup::Types::XRefLocation, facebook::glean::cpp::schema::Code::Anglelang::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.anglelang.AngleFileEntityXRefLocations";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct AngleFileEntityXRefLocations

struct AngleResolveLocation : Predicate<std::tuple<facebook::glean::cpp::schema::Codemarkup::Types::Location, facebook::glean::cpp::schema::Code::Anglelang::Entity>> {
  static const char* GLEAN_name() {
    return "codemarkup.anglelang.AngleResolveLocation";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct AngleResolveLocation

} // namespace Anglelang

} // namespace Codemarkup

namespace Search {

namespace Anglelang {

struct SearchByName : Predicate<std::tuple<Fact<facebook::glean::cpp::schema::Anglelang::Name>, facebook::glean::cpp::schema::Code::Anglelang::Entity>> {
  static const char* GLEAN_name() {
    return "search.anglelang.SearchByName";
  }

  static constexpr size_t GLEAN_version() {
     return 1;
  }
}; // struct SearchByName

} // namespace Anglelang

} // namespace Search

struct SCHEMA {
  template<typename P> struct index;
  static constexpr size_t count = 1157;
  static constexpr char schemaId[] = "d90d0945fb0ce9e863db84e05c868ba3";
  template<size_t i> struct predicate;
};

template<> struct SCHEMA::index<facebook::glean::cpp::schema::Sys::Blob> { static constexpr size_t value = 0; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Src::RangeContains> { static constexpr size_t value = 1; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Src::IndexFailure> { static constexpr size_t value = 2; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Src::FileLines> { static constexpr size_t value = 3; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Src::FileLanguage> { static constexpr size_t value = 4; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Src::FileDigest> { static constexpr size_t value = 5; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Src::File> { static constexpr size_t value = 6; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Src::ByteSpanContains> { static constexpr size_t value = 7; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Python::QueryToScopeCase> { static constexpr size_t value = 8; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Python::PythonNameCase> { static constexpr size_t value = 9; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Pp::SearchByName> { static constexpr size_t value = 10; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Java::QueryToScopeCase> { static constexpr size_t value = 11; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Java::NameCase> { static constexpr size_t value = 12; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::QueryToScopeCase> { static constexpr size_t value = 13; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::HackNameCase> { static constexpr size_t value = 14; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::HackInAutoImportedNamespace> { static constexpr size_t value = 15; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Flow::TypeDeclarationAsDeclaration> { static constexpr size_t value = 16; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Flow::QueryToScopeCase> { static constexpr size_t value = 17; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Flow::FlowModuleNameCase> { static constexpr size_t value = 18; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Cxx::QueryToQNameCase> { static constexpr size_t value = 19; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Cxx::QueryToNSQNameCase> { static constexpr size_t value = 20; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Cxx::CxxRecordCase> { static constexpr size_t value = 21; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Cxx::CxxNamespaceCase> { static constexpr size_t value = 22; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Anglelang::NameLowerCase> { static constexpr size_t value = 23; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::SymbolName> { static constexpr size_t value = 24; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::SymbolDocumentation> { static constexpr size_t value = 25; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::SymbolDisplayName> { static constexpr size_t value = 26; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::Symbol> { static constexpr size_t value = 27; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::ReferenceTarget> { static constexpr size_t value = 28; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::Reference> { static constexpr size_t value = 29; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::LocalName> { static constexpr size_t value = 30; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::IsImplemented> { static constexpr size_t value = 31; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::IsImplementation> { static constexpr size_t value = 32; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::EntityDefinition> { static constexpr size_t value = 33; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::EntityLocation> { static constexpr size_t value = 34; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::EntityUses> { static constexpr size_t value = 35; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::FileEntityXRefLocation> { static constexpr size_t value = 36; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::ResolveLocation> { static constexpr size_t value = 37; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::SearchBySymbol> { static constexpr size_t value = 38; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::Documentation> { static constexpr size_t value = 39; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::DisplayNameSymbol> { static constexpr size_t value = 40; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::DisplayName> { static constexpr size_t value = 41; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::DefinitionUses> { static constexpr size_t value = 42; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::DefinitionName> { static constexpr size_t value = 43; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::DefinitionDocumentation> { static constexpr size_t value = 44; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::Definition> { static constexpr size_t value = 45; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::Branches::Root> { static constexpr size_t value = 46; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::Branches::FileToRoot> { static constexpr size_t value = 47; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::Branches::DirectXRefByFile> { static constexpr size_t value = 48; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::XRefsViaNameByTarget> { static constexpr size_t value = 49; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::XRefsViaName> { static constexpr size_t value = 50; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::XRefsViaNameByFile> { static constexpr size_t value = 51; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::VariableDeclaration> { static constexpr size_t value = 52; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::VariableBySName> { static constexpr size_t value = 53; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::Type> { static constexpr size_t value = 54; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::StringLiteral> { static constexpr size_t value = 55; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchVariableByName> { static constexpr size_t value = 56; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchVariableByLowerCaseName> { static constexpr size_t value = 57; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchModuleByName> { static constexpr size_t value = 58; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchModuleByLowerCaseName> { static constexpr size_t value = 59; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchMethodByName> { static constexpr size_t value = 60; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchMethodByLowerCaseName> { static constexpr size_t value = 61; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchFunctionByName> { static constexpr size_t value = 62; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchFunctionByLowerCaseName> { static constexpr size_t value = 63; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchFieldByName> { static constexpr size_t value = 64; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchFieldByLowerCaseName> { static constexpr size_t value = 65; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchClassByName> { static constexpr size_t value = 66; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SearchClassByLowerCaseName> { static constexpr size_t value = 67; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SNameToName> { static constexpr size_t value = 68; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SName> { static constexpr size_t value = 69; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ResolveOriginalName> { static constexpr size_t value = 70; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::NameToSName> { static constexpr size_t value = 71; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::Name> { static constexpr size_t value = 72; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ModuleDefinition> { static constexpr size_t value = 73; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ModuleBySName> { static constexpr size_t value = 74; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::Module> { static constexpr size_t value = 75; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::MethodOverrides> { static constexpr size_t value = 76; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::MethodOverriden> { static constexpr size_t value = 77; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::MethodByLocalNameStr> { static constexpr size_t value = 78; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ImportStatementByAsSName> { static constexpr size_t value = 79; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ImportStatementByAsName> { static constexpr size_t value = 80; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ImportStatement> { static constexpr size_t value = 81; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ImportStarsByFile> { static constexpr size_t value = 82; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ImportStarStatement> { static constexpr size_t value = 83; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ImportStarLocation> { static constexpr size_t value = 84; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::FunctionDeclaration> { static constexpr size_t value = 85; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::FunctionBySName> { static constexpr size_t value = 86; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DerivedClassToBase> { static constexpr size_t value = 87; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DefinitionLocation> { static constexpr size_t value = 88; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DefinitionsByFile> { static constexpr size_t value = 89; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::IsTopLevelDefinition> { static constexpr size_t value = 90; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::FunctionDefinition> { static constexpr size_t value = 91; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::VariableDefinition> { static constexpr size_t value = 92; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DeclarationDefinition> { static constexpr size_t value = 93; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DeclarationDocstring> { static constexpr size_t value = 94; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DeclarationLocation> { static constexpr size_t value = 95; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DeclarationReference> { static constexpr size_t value = 96; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DeclarationToName> { static constexpr size_t value = 97; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DeclarationUses> { static constexpr size_t value = 98; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DeclarationWithLocalName> { static constexpr size_t value = 99; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DeclarationWithName> { static constexpr size_t value = 100; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DeclarationWithSName> { static constexpr size_t value = 101; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DeclarationsByFile> { static constexpr size_t value = 102; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DefinitionDeclaration> { static constexpr size_t value = 103; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::DirectXRefsByFile> { static constexpr size_t value = 104; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::IsAbstract> { static constexpr size_t value = 105; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::IsTopLevelDeclaration> { static constexpr size_t value = 106; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::NonImportDeclaration> { static constexpr size_t value = 107; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::SNameWithDeclaration> { static constexpr size_t value = 108; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Yaml::XRefsByFile> { static constexpr size_t value = 109; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::Contains> { static constexpr size_t value = 110; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ContainingTopLevelDeclaration> { static constexpr size_t value = 111; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ContainedByTopLevelDeclaration> { static constexpr size_t value = 112; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ContainedBy> { static constexpr size_t value = 113; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ClassDefinition> { static constexpr size_t value = 114; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ClassDeclaration> { static constexpr size_t value = 115; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::ClassBySName> { static constexpr size_t value = 116; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::CalleeToCaller> { static constexpr size_t value = 117; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::BaseClassToDerived> { static constexpr size_t value = 118; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Python::FileCall> { static constexpr size_t value = 119; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Pp1::Use> { static constexpr size_t value = 120; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Pp1::Undef> { static constexpr size_t value = 121; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Pp1::Macro> { static constexpr size_t value = 122; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Pp1::Include> { static constexpr size_t value = 123; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Pp1::DefineUse> { static constexpr size_t value = 124; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Pp1::DefineLowerCase> { static constexpr size_t value = 125; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Pp1::Define> { static constexpr size_t value = 126; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::Metadata> { static constexpr size_t value = 127; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::EntityKind> { static constexpr size_t value = 128; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::SearchByNameKind> { static constexpr size_t value = 129; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::SymbolKind> { static constexpr size_t value = 130; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::Types::ToSrcRange> { static constexpr size_t value = 131; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::DefinitionLocation> { static constexpr size_t value = 132; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::FileRange> { static constexpr size_t value = 133; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::FileXLangSymbolRef> { static constexpr size_t value = 134; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::ReferenceLocation> { static constexpr size_t value = 135; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::FileLanguage> { static constexpr size_t value = 136; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Scip::TagDefinition> { static constexpr size_t value = 137; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::Types::FromSrcRange> { static constexpr size_t value = 138; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::Reference> { static constexpr size_t value = 139; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::Range> { static constexpr size_t value = 140; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::ProjectDocument> { static constexpr size_t value = 141; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::Project> { static constexpr size_t value = 142; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::PackageInformation> { static constexpr size_t value = 143; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::NameLowerCase> { static constexpr size_t value = 144; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::NameDefinition> { static constexpr size_t value = 145; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::Name> { static constexpr size_t value = 146; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::MonikerSymbolKind> { static constexpr size_t value = 147; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::MonikerScheme> { static constexpr size_t value = 148; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::MonikerId> { static constexpr size_t value = 149; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::MonikerDefinition> { static constexpr size_t value = 150; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::Moniker> { static constexpr size_t value = 151; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::Metadata> { static constexpr size_t value = 152; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::HoverText> { static constexpr size_t value = 153; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::HoverContent> { static constexpr size_t value = 154; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::EntityDefinition> { static constexpr size_t value = 155; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::EntityKind> { static constexpr size_t value = 156; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::EntityLocation> { static constexpr size_t value = 157; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::EntityUses> { static constexpr size_t value = 158; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::FileEntityXRefLocation> { static constexpr size_t value = 159; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::ResolveLocation> { static constexpr size_t value = 160; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::SearchByExactLocation> { static constexpr size_t value = 161; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::SearchByExactLocationAndName> { static constexpr size_t value = 162; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::SearchByMoniker> { static constexpr size_t value = 163; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::SearchByName> { static constexpr size_t value = 164; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::SearchNonLocalByLocation> { static constexpr size_t value = 165; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::TagDefinition> { static constexpr size_t value = 166; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::Document> { static constexpr size_t value = 167; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::DefinitionUse> { static constexpr size_t value = 168; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::DefinitionMoniker> { static constexpr size_t value = 169; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::DefinitionLocation> { static constexpr size_t value = 170; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::DefinitionKind> { static constexpr size_t value = 171; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::DefinitionHover> { static constexpr size_t value = 172; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::Definition> { static constexpr size_t value = 173; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Lsif::Declaration> { static constexpr size_t value = 174; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::VariableParent> { static constexpr size_t value = 175; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::VariableDeclaration> { static constexpr size_t value = 176; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::TypeArg> { static constexpr size_t value = 177; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::Type> { static constexpr size_t value = 178; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::DeclarationLocation> { static constexpr size_t value = 179; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::DeclarationFileLocation> { static constexpr size_t value = 180; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::ExtendsDeclaration> { static constexpr size_t value = 181; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::FileDeclarations> { static constexpr size_t value = 182; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::MethodDeclaration> { static constexpr size_t value = 183; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::ParentDeclaration> { static constexpr size_t value = 184; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Kotlin::SearchByQName> { static constexpr size_t value = 185; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Kotlin::LookupDeclaration> { static constexpr size_t value = 186; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Kotlin::LookupMethodDeclaration> { static constexpr size_t value = 187; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::ContainsDeclaration> { static constexpr size_t value = 188; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::ClassMember> { static constexpr size_t value = 189; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Kotlin::Alpha::ClassDeclaration> { static constexpr size_t value = 190; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Javakotlin::Alpha::Type> { static constexpr size_t value = 191; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Javakotlin::Alpha::QName> { static constexpr size_t value = 192; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Javakotlin::Alpha::Path> { static constexpr size_t value = 193; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Javakotlin::Alpha::NameLowerCase> { static constexpr size_t value = 194; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Javakotlin::Alpha::Name> { static constexpr size_t value = 195; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName> { static constexpr size_t value = 196; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::XRefFile> { static constexpr size_t value = 197; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::XRef> { static constexpr size_t value = 198; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::TypeVar> { static constexpr size_t value = 199; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::TypeParam> { static constexpr size_t value = 200; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::TypeOfTypeArgs> { static constexpr size_t value = 201; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::TypeArg> { static constexpr size_t value = 202; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::PrimitiveType> { static constexpr size_t value = 203; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::PackageDeclaration> { static constexpr size_t value = 204; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::ObjectType> { static constexpr size_t value = 205; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::ParameterDeclaration> { static constexpr size_t value = 206; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::InterfaceInheritance> { static constexpr size_t value = 207; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::Inheritance> { static constexpr size_t value = 208; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::ImportDeclaration> { static constexpr size_t value = 209; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::FileXRefs> { static constexpr size_t value = 210; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::ExecutableDefnLocation> { static constexpr size_t value = 211; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::LocalDeclaration> { static constexpr size_t value = 212; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::DefinitionLocation> { static constexpr size_t value = 213; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::EnumDeclaration> { static constexpr size_t value = 214; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::FieldDeclaration> { static constexpr size_t value = 215; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::InterfaceDeclaration> { static constexpr size_t value = 216; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::MethodDeclaration> { static constexpr size_t value = 217; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::DeclarationAnnotations> { static constexpr size_t value = 218; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::DeclarationComment> { static constexpr size_t value = 219; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::DeclarationLocation> { static constexpr size_t value = 220; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::DeclarationType> { static constexpr size_t value = 221; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::DeclarationUses> { static constexpr size_t value = 222; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::DeclarationXRefTarget> { static constexpr size_t value = 223; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::ExtendedByDeclaration> { static constexpr size_t value = 224; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::ExtendsDeclaration> { static constexpr size_t value = 225; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::FileDeclarations> { static constexpr size_t value = 226; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::ParentDeclaration> { static constexpr size_t value = 227; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::QNameToDefinition> { static constexpr size_t value = 228; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::XRefOfType> { static constexpr size_t value = 229; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::XRefTargetDeclaration> { static constexpr size_t value = 230; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Java::SearchByQName> { static constexpr size_t value = 231; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Java::LookupDeclaration> { static constexpr size_t value = 232; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Java::LookupMethodDeclaration> { static constexpr size_t value = 233; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::DeclOfExecutableDefn> { static constexpr size_t value = 234; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::DeclOfDefn> { static constexpr size_t value = 235; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::ContainsDeclaration> { static constexpr size_t value = 236; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::ConstructorDeclaration> { static constexpr size_t value = 237; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::ClassDeclaration> { static constexpr size_t value = 238; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::Type> { static constexpr size_t value = 239; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::ArrayType> { static constexpr size_t value = 240; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::Annotation> { static constexpr size_t value = 241; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Java::Alpha::AnnotatedClass> { static constexpr size_t value = 242; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Indexer::Config> { static constexpr size_t value = 243; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::ValBind> { static constexpr size_t value = 244; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::UnitName> { static constexpr size_t value = 245; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::TypeSynDecl> { static constexpr size_t value = 246; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::TypeFamilyDecl> { static constexpr size_t value = 247; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::TyVarBind> { static constexpr size_t value = 248; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::TyCon> { static constexpr size_t value = 249; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::SourceModule> { static constexpr size_t value = 250; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::SigDecl> { static constexpr size_t value = 251; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::XRef> { static constexpr size_t value = 252; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::RecordFieldDecl> { static constexpr size_t value = 253; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::PatSynDecl> { static constexpr size_t value = 254; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::PatBind> { static constexpr size_t value = 255; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::OccNameLowerCase> { static constexpr size_t value = 256; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::OccName> { static constexpr size_t value = 257; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::Name> { static constexpr size_t value = 258; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::ModuleSource> { static constexpr size_t value = 259; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::ModuleName> { static constexpr size_t value = 260; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::ModuleDeclarations> { static constexpr size_t value = 261; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::Module> { static constexpr size_t value = 262; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::MethDecl> { static constexpr size_t value = 263; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::LitType> { static constexpr size_t value = 264; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::InstanceDecl> { static constexpr size_t value = 265; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::InstanceBindToDecl> { static constexpr size_t value = 266; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::InstanceBind> { static constexpr size_t value = 267; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::FileXRefs> { static constexpr size_t value = 268; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::DeclarationLocation> { static constexpr size_t value = 269; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::DeclarationOfName> { static constexpr size_t value = 270; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::DeclarationSpan> { static constexpr size_t value = 271; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::DataDecl> { static constexpr size_t value = 272; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::ConstrDecl> { static constexpr size_t value = 273; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::ClassDecl> { static constexpr size_t value = 274; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hs::Type> { static constexpr size_t value = 275; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::UserAttribute> { static constexpr size_t value = 276; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::TypedefDeclaration> { static constexpr size_t value = 277; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::TypeConstDefinition> { static constexpr size_t value = 278; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::Type> { static constexpr size_t value = 279; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::TraitDeclaration> { static constexpr size_t value = 280; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::StringLiteral> { static constexpr size_t value = 281; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchTypedefByLowerCaseName> { static constexpr size_t value = 282; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchTypeConstByLowerCaseName> { static constexpr size_t value = 283; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchTraitByLowerCaseName> { static constexpr size_t value = 284; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchPropertyByLowerCaseName> { static constexpr size_t value = 285; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchNamespaceByLowerCaseName> { static constexpr size_t value = 286; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchModuleByLowerCaseName> { static constexpr size_t value = 287; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchMethodByLowerCaseName> { static constexpr size_t value = 288; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchInterfaceByLowerCaseName> { static constexpr size_t value = 289; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchGlobalConstByLowerCaseName> { static constexpr size_t value = 290; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchFunctionByLowerCaseName> { static constexpr size_t value = 291; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchEnumeratorByLowerCaseName> { static constexpr size_t value = 292; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchEnumByLowerCaseName> { static constexpr size_t value = 293; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchClassConstByLowerCaseName> { static constexpr size_t value = 294; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchClassByLowerCaseName> { static constexpr size_t value = 295; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::QName> { static constexpr size_t value = 296; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::PropertyDefinition> { static constexpr size_t value = 297; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::Signature> { static constexpr size_t value = 298; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::NamespaceQName> { static constexpr size_t value = 299; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::NamespaceDeclaration> { static constexpr size_t value = 300; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::NameLowerCase> { static constexpr size_t value = 301; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::Name> { static constexpr size_t value = 302; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ModuleDefinition> { static constexpr size_t value = 303; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ModuleDeclaration> { static constexpr size_t value = 304; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::MethodOverrides> { static constexpr size_t value = 305; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::MethodOverridden> { static constexpr size_t value = 306; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::MethodOccurrence> { static constexpr size_t value = 307; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::InterfaceDeclaration> { static constexpr size_t value = 308; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::IndexerInputsHash> { static constexpr size_t value = 309; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::GlobalNamespaceAlias> { static constexpr size_t value = 310; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::GlobalConstDefinition> { static constexpr size_t value = 311; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::GlobalConstDeclaration> { static constexpr size_t value = 312; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::FunctionDeclaration> { static constexpr size_t value = 313; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::Hint> { static constexpr size_t value = 314; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::Enumerator> { static constexpr size_t value = 315; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::EnumDefinition> { static constexpr size_t value = 316; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::EnumDeclaration> { static constexpr size_t value = 317; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::Context_> { static constexpr size_t value = 318; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ContainerDeclarationQName> { static constexpr size_t value = 319; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ContainerParent> { static constexpr size_t value = 320; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::DeclarationComment> { static constexpr size_t value = 321; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::DeclarationLocation> { static constexpr size_t value = 322; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::DeclarationName> { static constexpr size_t value = 323; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::DeclarationNamespace> { static constexpr size_t value = 324; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::DeclarationSource> { static constexpr size_t value = 325; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::DeclarationSpan> { static constexpr size_t value = 326; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::DeclarationTarget> { static constexpr size_t value = 327; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::FileDeclarations> { static constexpr size_t value = 328; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::MemberCluster> { static constexpr size_t value = 329; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ModuleChild> { static constexpr size_t value = 330; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ModuleParent> { static constexpr size_t value = 331; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::NamespaceMember> { static constexpr size_t value = 332; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchClassByName> { static constexpr size_t value = 333; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchClassConstByName> { static constexpr size_t value = 334; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchEnumByName> { static constexpr size_t value = 335; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchEnumeratorByName> { static constexpr size_t value = 336; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchFunctionByName> { static constexpr size_t value = 337; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchGlobalConstByName> { static constexpr size_t value = 338; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchInterfaceByName> { static constexpr size_t value = 339; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchMethodByName> { static constexpr size_t value = 340; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchModuleByName> { static constexpr size_t value = 341; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchNamespaceByName> { static constexpr size_t value = 342; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchPropertyByName> { static constexpr size_t value = 343; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchTraitByName> { static constexpr size_t value = 344; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchTypeConstByName> { static constexpr size_t value = 345; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::SearchTypedefByName> { static constexpr size_t value = 346; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::TargetUses> { static constexpr size_t value = 347; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::TargetUsesAbs> { static constexpr size_t value = 348; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::FileXRefs> { static constexpr size_t value = 349; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::TypeInfo> { static constexpr size_t value = 350; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchByName> { static constexpr size_t value = 351; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchFunctionInNamespace> { static constexpr size_t value = 352; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchGlobalConstInNamespace> { static constexpr size_t value = 353; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchInContainer> { static constexpr size_t value = 354; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchInContainerNoProperty> { static constexpr size_t value = 355; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchInContainerOrEnum> { static constexpr size_t value = 356; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchInContainerOrEnumNoProperty> { static constexpr size_t value = 357; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchInEnum> { static constexpr size_t value = 358; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchInNamespace> { static constexpr size_t value = 359; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchModule> { static constexpr size_t value = 360; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchNamespace> { static constexpr size_t value = 361; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchNamespacedDecl> { static constexpr size_t value = 362; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchPropertyInContainer> { static constexpr size_t value = 363; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hack::SearchTypeInNamespace> { static constexpr size_t value = 364; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::InheritedMembers> { static constexpr size_t value = 365; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::MethodDeclaration> { static constexpr size_t value = 366; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::PropertyDeclaration> { static constexpr size_t value = 367; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::TypeConstDeclaration> { static constexpr size_t value = 368; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ContainerChild> { static constexpr size_t value = 369; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::FunctionDefinition> { static constexpr size_t value = 370; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::InterfaceDefinition> { static constexpr size_t value = 371; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::MethodDefinition> { static constexpr size_t value = 372; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::TraitDefinition> { static constexpr size_t value = 373; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::TypedefDefinition> { static constexpr size_t value = 374; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ClassDefinition> { static constexpr size_t value = 375; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ClassDeclaration> { static constexpr size_t value = 376; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ClassConstDefinition> { static constexpr size_t value = 377; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ClassConstDeclaration> { static constexpr size_t value = 378; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::AttributeToDefinition> { static constexpr size_t value = 379; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::AttributeToDeclaration> { static constexpr size_t value = 380; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::AttributeHasParameter> { static constexpr size_t value = 381; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::FileCall> { static constexpr size_t value = 382; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::VariableDef> { static constexpr size_t value = 383; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::Value> { static constexpr size_t value = 384; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::UnionTypeDef> { static constexpr size_t value = 385; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::ScalarTypeDef> { static constexpr size_t value = 386; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::Operation> { static constexpr size_t value = 387; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::ObjectTypeDef> { static constexpr size_t value = 388; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::NameLowerCase> { static constexpr size_t value = 389; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::InterfaceTypeDef> { static constexpr size_t value = 390; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::InputValueDef> { static constexpr size_t value = 391; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::InputObjectTypeDef> { static constexpr size_t value = 392; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::InlineFragment> { static constexpr size_t value = 393; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::FragmentSpread> { static constexpr size_t value = 394; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::Fragment> { static constexpr size_t value = 395; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::FieldDef> { static constexpr size_t value = 396; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::Field> { static constexpr size_t value = 397; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::EnumTypeDef> { static constexpr size_t value = 398; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::DirectiveDef> { static constexpr size_t value = 399; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::Directive> { static constexpr size_t value = 400; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::DeclarationLocation> { static constexpr size_t value = 401; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::DeclarationName> { static constexpr size_t value = 402; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::DeclarationUses> { static constexpr size_t value = 403; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::FileDeclarations> { static constexpr size_t value = 404; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::SearchByName> { static constexpr size_t value = 405; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::FileXRefs> { static constexpr size_t value = 406; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::DeclHasName> { static constexpr size_t value = 407; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::BelongToConfig> { static constexpr size_t value = 408; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Graphql::Argument> { static constexpr size_t value = 409; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::nothingTest> { static constexpr size_t value = 410; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::ViaStringPair> { static constexpr size_t value = 411; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Unbound2> { static constexpr size_t value = 412; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Unbound> { static constexpr size_t value = 413; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::TreeToTree> { static constexpr size_t value = 414; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Tree> { static constexpr size_t value = 415; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::StringPairBox> { static constexpr size_t value = 416; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::StringPair> { static constexpr size_t value = 417; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::StoredRevStringPairWithRev> { static constexpr size_t value = 418; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::StoredRevStringPairWithA> { static constexpr size_t value = 419; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::StoredRevStringPairSum> { static constexpr size_t value = 420; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::StoredRevStringPair> { static constexpr size_t value = 421; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::StoredDualStringPair> { static constexpr size_t value = 422; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::SkipRevEdge> { static constexpr size_t value = 423; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::SameString> { static constexpr size_t value = 424; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::RevStringPairs> { static constexpr size_t value = 425; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::RevStringPairRec> { static constexpr size_t value = 426; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::RevStringPair> { static constexpr size_t value = 427; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::RevRevStringPair> { static constexpr size_t value = 428; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::RevEdge> { static constexpr size_t value = 429; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::ReflStringPair> { static constexpr size_t value = 430; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::RefRef> { static constexpr size_t value = 431; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Ref> { static constexpr size_t value = 432; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Qux> { static constexpr size_t value = 433; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Predicate_0> { static constexpr size_t value = 434; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::NodePair> { static constexpr size_t value = 435; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Node> { static constexpr size_t value = 436; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Name> { static constexpr size_t value = 437; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::MatchOneAlt> { static constexpr size_t value = 438; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::LeftOr2> { static constexpr size_t value = 439; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::LeftOr> { static constexpr size_t value = 440; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::KeyValue> { static constexpr size_t value = 441; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::IsThree> { static constexpr size_t value = 442; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::IsParent> { static constexpr size_t value = 443; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::IsGlean> { static constexpr size_t value = 444; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::FooToFoo> { static constexpr size_t value = 445; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Foo> { static constexpr size_t value = 446; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Expr> { static constexpr size_t value = 447; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::EmptyStoredStringPair> { static constexpr size_t value = 448; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::EmptyPred> { static constexpr size_t value = 449; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::EdgeWrapper> { static constexpr size_t value = 450; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::EdgeFromNotA> { static constexpr size_t value = 451; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Edge> { static constexpr size_t value = 452; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::DualStringPair> { static constexpr size_t value = 453; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::DerivedKeyValue2> { static constexpr size_t value = 454; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::DerivedKeyValue> { static constexpr size_t value = 455; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Bar> { static constexpr size_t value = 456; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glean::Test::Predicate_> { static constexpr size_t value = 457; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Gencode::GenCodeSignature> { static constexpr size_t value = 458; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Gencode::GenCodeCommand> { static constexpr size_t value = 459; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Gencode::GenCodeClass> { static constexpr size_t value = 460; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Gencode::GenCodeBySource> { static constexpr size_t value = 461; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Gencode::GenCode> { static constexpr size_t value = 462; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::TypeImportDeclaration> { static constexpr size_t value = 463; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::TypeExport> { static constexpr size_t value = 464; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::TypeDeclarationReference> { static constexpr size_t value = 465; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::TypeDeclarationInfo> { static constexpr size_t value = 466; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::TypeDeclaration> { static constexpr size_t value = 467; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::Type> { static constexpr size_t value = 468; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::StringToFileModule> { static constexpr size_t value = 469; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SourceOfTypeExport> { static constexpr size_t value = 470; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SourceOfExport> { static constexpr size_t value = 471; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Flow::FlowSearchByNameNonImport> { static constexpr size_t value = 472; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchTypeDeclarationByName> { static constexpr size_t value = 473; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchTypeDeclarationByLowerCaseName> { static constexpr size_t value = 474; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchTypeByModuleExport> { static constexpr size_t value = 475; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchModuleByLowerCaseName> { static constexpr size_t value = 476; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchMemberDeclarationByName> { static constexpr size_t value = 477; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchMemberDeclarationByLowerCaseName> { static constexpr size_t value = 478; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchDeclarationByName> { static constexpr size_t value = 479; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchDeclarationByLowerCaseName> { static constexpr size_t value = 480; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchByNameModule> { static constexpr size_t value = 481; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchByName> { static constexpr size_t value = 482; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchByModuleName> { static constexpr size_t value = 483; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchByModule> { static constexpr size_t value = 484; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::SearchByFileModule> { static constexpr size_t value = 485; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::Range> { static constexpr size_t value = 486; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::Name> { static constexpr size_t value = 487; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::ModuleTypeExport> { static constexpr size_t value = 488; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::ModuleNameLowerCase> { static constexpr size_t value = 489; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::ModuleLocationByFile> { static constexpr size_t value = 490; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::ModuleLocation> { static constexpr size_t value = 491; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::ModuleExport> { static constexpr size_t value = 492; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::ModuleDoc> { static constexpr size_t value = 493; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::ModuleContains> { static constexpr size_t value = 494; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::ModuleComments> { static constexpr size_t value = 495; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::Module> { static constexpr size_t value = 496; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::MemberDeclarationReference> { static constexpr size_t value = 497; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::MemberDeclarationInfo> { static constexpr size_t value = 498; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::MemberDeclaration> { static constexpr size_t value = 499; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::LocalDeclarationReference> { static constexpr size_t value = 500; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::ImportDeclaration> { static constexpr size_t value = 501; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FlowXRefDeclInfo> { static constexpr size_t value = 502; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FlowTypeImportXRef> { static constexpr size_t value = 503; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FlowTypeExportLocation> { static constexpr size_t value = 504; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FlowTypeEntityImportUses> { static constexpr size_t value = 505; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FlowSameModule> { static constexpr size_t value = 506; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FlowModuleNamespaceXRef> { static constexpr size_t value = 507; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FlowImportXRef> { static constexpr size_t value = 508; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FlowExportLocation> { static constexpr size_t value = 509; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FlowEntityUsesAll> { static constexpr size_t value = 510; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FlowEntityImportUses> { static constexpr size_t value = 511; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FlowCompatibleExport> { static constexpr size_t value = 512; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FileXRef> { static constexpr size_t value = 513; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FileOfStringModule> { static constexpr size_t value = 514; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::FileDeclaration> { static constexpr size_t value = 515; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::Export> { static constexpr size_t value = 516; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::Documentation> { static constexpr size_t value = 517; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::DeclarationUses> { static constexpr size_t value = 518; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::DeclarationSignature> { static constexpr size_t value = 519; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::DeclarationNameSpan> { static constexpr size_t value = 520; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::DeclarationLocation> { static constexpr size_t value = 521; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::DeclarationInfo> { static constexpr size_t value = 522; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Flow::Declaration> { static constexpr size_t value = 523; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::UnionVal> { static constexpr size_t value = 524; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::TypeDefType> { static constexpr size_t value = 525; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::StructuredAnnotation> { static constexpr size_t value = 526; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::StructVal> { static constexpr size_t value = 527; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::ServiceParent> { static constexpr size_t value = 528; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::ServiceName> { static constexpr size_t value = 529; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::ServiceInteractionFunctions> { static constexpr size_t value = 530; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::ServiceDefinition> { static constexpr size_t value = 531; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::ServiceChild> { static constexpr size_t value = 532; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::SearchByName> { static constexpr size_t value = 533; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::QualName> { static constexpr size_t value = 534; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::PackageName> { static constexpr size_t value = 535; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::Package> { static constexpr size_t value = 536; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::NamespaceValue> { static constexpr size_t value = 537; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::NamespaceName> { static constexpr size_t value = 538; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::Namespace> { static constexpr size_t value = 539; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::NamedDecl> { static constexpr size_t value = 540; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::NameLowerCase> { static constexpr size_t value = 541; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::InteractionName> { static constexpr size_t value = 542; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::InteractionDefinition> { static constexpr size_t value = 543; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::Identifier> { static constexpr size_t value = 544; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::FunctionName> { static constexpr size_t value = 545; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::Literal> { static constexpr size_t value = 546; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::FileXRefs> { static constexpr size_t value = 547; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::File> { static constexpr size_t value = 548; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::StructType> { static constexpr size_t value = 549; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::UnionType> { static constexpr size_t value = 550; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::FieldDecl> { static constexpr size_t value = 551; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::ExceptionVal> { static constexpr size_t value = 552; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::ExceptionType> { static constexpr size_t value = 553; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::TypeDefException> { static constexpr size_t value = 554; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::ExceptionName> { static constexpr size_t value = 555; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::EnumerationType> { static constexpr size_t value = 556; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::EnumValueDef> { static constexpr size_t value = 557; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::EnumValue> { static constexpr size_t value = 558; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::EnumVal> { static constexpr size_t value = 559; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::DeclarationComment> { static constexpr size_t value = 560; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::DeclarationFile> { static constexpr size_t value = 561; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::DeclarationMember> { static constexpr size_t value = 562; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::DeclarationName> { static constexpr size_t value = 563; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::DeclarationNameSpan> { static constexpr size_t value = 564; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::DeclarationUses> { static constexpr size_t value = 565; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::FileDeclaration> { static constexpr size_t value = 566; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::FunctionDeclarationName> { static constexpr size_t value = 567; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::HackToThrift> { static constexpr size_t value = 568; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Hack::ThriftToHack> { static constexpr size_t value = 569; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::TypeSpecification> { static constexpr size_t value = 570; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::ConstantDefinition> { static constexpr size_t value = 571; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::Constant> { static constexpr size_t value = 572; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Erlang::NameLowerCase> { static constexpr size_t value = 573; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Erlang::FunctionDeclaration> { static constexpr size_t value = 574; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Erlang::XRefsViaFqnByFile> { static constexpr size_t value = 575; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Erlang::DeclarationComment> { static constexpr size_t value = 576; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Erlang::DeclarationLocation> { static constexpr size_t value = 577; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Erlang::DeclarationReference> { static constexpr size_t value = 578; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Erlang::DeclarationToFqn> { static constexpr size_t value = 579; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Erlang::DeclarationUses> { static constexpr size_t value = 580; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Erlang::DeclarationWithFqn> { static constexpr size_t value = 581; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Erlang::DeclarationsByFile> { static constexpr size_t value = 582; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Erlang::SearchByName> { static constexpr size_t value = 583; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dyn::ObserverIdentifier> { static constexpr size_t value = 584; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dyn::Environment> { static constexpr size_t value = 585; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dyn::EntityDynamicReference> { static constexpr size_t value = 586; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Digest::FileDigest> { static constexpr size_t value = 587; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Glass::FileInfo> { static constexpr size_t value = 588; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dataswarm::TableDeclaration> { static constexpr size_t value = 589; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dataswarm::TableColumnDeclaration> { static constexpr size_t value = 590; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dataswarm::SubqueryDeclaration> { static constexpr size_t value = 591; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dataswarm::SubqueryColumnDeclaration> { static constexpr size_t value = 592; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dataswarm::MacroDeclaration> { static constexpr size_t value = 593; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dataswarm::DeclarationLocation> { static constexpr size_t value = 594; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dataswarm::DeclarationName> { static constexpr size_t value = 595; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dataswarm::XRefsByFile> { static constexpr size_t value = 596; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::VariableLowerCase> { static constexpr size_t value = 597; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::UsingDirective> { static constexpr size_t value = 598; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::UsingDeclaration> { static constexpr size_t value = 599; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::TypeAliasLowerCase> { static constexpr size_t value = 600; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::TypeAliasDeclaration> { static constexpr size_t value = 601; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::Type> { static constexpr size_t value = 602; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::TranslationUnitXRefs> { static constexpr size_t value = 603; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::TranslationUnitTrace> { static constexpr size_t value = 604; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::TranslationUnitIncludeTree> { static constexpr size_t value = 605; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::Trace> { static constexpr size_t value = 606; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::RecordUnionLowerCase> { static constexpr size_t value = 607; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::RecordStructLowerCase> { static constexpr size_t value = 608; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::RecordDerived> { static constexpr size_t value = 609; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::RecordClassLowerCase> { static constexpr size_t value = 610; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::Signature> { static constexpr size_t value = 611; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::PPDefineLocation> { static constexpr size_t value = 612; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcSelector> { static constexpr size_t value = 613; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcPropertyImplementation> { static constexpr size_t value = 614; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcPropertyIVar> { static constexpr size_t value = 615; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcMethodDefinition> { static constexpr size_t value = 616; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcMethodDeclarationName> { static constexpr size_t value = 617; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcInterfaceToImplementation> { static constexpr size_t value = 618; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcImplements> { static constexpr size_t value = 619; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcContainerInterfaceLowerCase> { static constexpr size_t value = 620; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcContainerInheritance> { static constexpr size_t value = 621; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcContainerDefinition> { static constexpr size_t value = 622; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcContainerDeclarationInterface> { static constexpr size_t value = 623; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcContainerBase> { static constexpr size_t value = 624; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcContainerDeclaration> { static constexpr size_t value = 625; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcMethodDeclaration> { static constexpr size_t value = 626; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjcPropertyDeclaration> { static constexpr size_t value = 627; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ObjContainerIdName> { static constexpr size_t value = 628; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::NamespaceQName> { static constexpr size_t value = 629; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::NamespaceLowerCase> { static constexpr size_t value = 630; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::NamespaceDefinition> { static constexpr size_t value = 631; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::NamespaceDeclarationName> { static constexpr size_t value = 632; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::NamespaceDeclarationByName> { static constexpr size_t value = 633; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::NamespaceDeclaration> { static constexpr size_t value = 634; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::NamespaceAliasDeclaration> { static constexpr size_t value = 635; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::Name> { static constexpr size_t value = 636; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::MethodOverrides> { static constexpr size_t value = 637; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::MethodOverridden> { static constexpr size_t value = 638; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::IncludeTreeTranslationUnit> { static constexpr size_t value = 639; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::IncludeTreeParent> { static constexpr size_t value = 640; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::IncludeTree> { static constexpr size_t value = 641; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::PPTrace> { static constexpr size_t value = 642; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FunctionLowerCase> { static constexpr size_t value = 643; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FunctionDefinition> { static constexpr size_t value = 644; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FunctionDeclarationNameString> { static constexpr size_t value = 645; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FunctionDeclarationName> { static constexpr size_t value = 646; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FunctionDeclaration> { static constexpr size_t value = 647; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FunctionDeclAttribute> { static constexpr size_t value = 648; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FunctionAttribute> { static constexpr size_t value = 649; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FileXRefs> { static constexpr size_t value = 650; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FilePPUseXRefs> { static constexpr size_t value = 651; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FilePPUseTraceXRefs> { static constexpr size_t value = 652; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FilePPTraceXRefs> { static constexpr size_t value = 653; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::VariableDeclaration> { static constexpr size_t value = 654; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::EnumeratorLowerCase> { static constexpr size_t value = 655; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::EnumeratorInEnum> { static constexpr size_t value = 656; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::EnumeratorByName> { static constexpr size_t value = 657; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::Enumerator> { static constexpr size_t value = 658; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::EnumLowerCase> { static constexpr size_t value = 659; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::EnumDefinition> { static constexpr size_t value = 660; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::EnumDeclaration> { static constexpr size_t value = 661; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DefnInRecord> { static constexpr size_t value = 662; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclarationComment> { static constexpr size_t value = 663; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclarationInTrace> { static constexpr size_t value = 664; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclarationLocationName> { static constexpr size_t value = 665; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclarationLocationNameSpan> { static constexpr size_t value = 666; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclarationNameSpan> { static constexpr size_t value = 667; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclarationSources> { static constexpr size_t value = 668; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclarationSrcRange> { static constexpr size_t value = 669; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclarationTargets> { static constexpr size_t value = 670; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclarationToUSR> { static constexpr size_t value = 671; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::Declarations> { static constexpr size_t value = 672; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DefToBaseDecl> { static constexpr size_t value = 673; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::MangledNameHashToDeclaration> { static constexpr size_t value = 674; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::Same> { static constexpr size_t value = 675; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::USRToDeclaration> { static constexpr size_t value = 676; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FileXRefMap> { static constexpr size_t value = 677; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::SpellingXRef> { static constexpr size_t value = 678; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::TargetUses> { static constexpr size_t value = 679; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::ThriftToCxx> { static constexpr size_t value = 680; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::XRefIndirectTarget> { static constexpr size_t value = 681; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::XRefTargets> { static constexpr size_t value = 682; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::LookupNamespaceDeclaration> { static constexpr size_t value = 683; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclToFamily> { static constexpr size_t value = 684; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclInRecord> { static constexpr size_t value = 685; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclInObjcContainer> { static constexpr size_t value = 686; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclFamilyOf> { static constexpr size_t value = 687; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclFamily> { static constexpr size_t value = 688; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::CxxToThrift> { static constexpr size_t value = 689; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::Attribute> { static constexpr size_t value = 690; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::RecordDefinition> { static constexpr size_t value = 691; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::UnityPackageToProject> { static constexpr size_t value = 692; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::UnityPackage> { static constexpr size_t value = 693; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::UnityProjectSource> { static constexpr size_t value = 694; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::TypeParameter> { static constexpr size_t value = 695; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::SourceFileToProject> { static constexpr size_t value = 696; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::SolutionToProject> { static constexpr size_t value = 697; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Solution> { static constexpr size_t value = 698; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::ProjectToSourceFile> { static constexpr size_t value = 699; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::ProjectToSolution> { static constexpr size_t value = 700; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Project> { static constexpr size_t value = 701; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Namespace> { static constexpr size_t value = 702; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::NameLowerCase> { static constexpr size_t value = 703; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Name> { static constexpr size_t value = 704; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::MSBuildProjectSource> { static constexpr size_t value = 705; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::MemberAccessLocation> { static constexpr size_t value = 706; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::MethodInvocationLocation> { static constexpr size_t value = 707; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Implements> { static constexpr size_t value = 708; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::FunctionPointerType> { static constexpr size_t value = 709; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::FullName> { static constexpr size_t value = 710; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Class> { static constexpr size_t value = 711; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Interface> { static constexpr size_t value = 712; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Record> { static constexpr size_t value = 713; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Struct> { static constexpr size_t value = 714; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::ArrayType> { static constexpr size_t value = 715; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::DefinitionLocation> { static constexpr size_t value = 716; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::DefinitionLocationName> { static constexpr size_t value = 717; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::FileDefinitions> { static constexpr size_t value = 718; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::FileEntityXRefs> { static constexpr size_t value = 719; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::SearchByName> { static constexpr size_t value = 720; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Field> { static constexpr size_t value = 721; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Local> { static constexpr size_t value = 722; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Method> { static constexpr size_t value = 723; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::ObjectCreationLocation> { static constexpr size_t value = 724; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Parameter> { static constexpr size_t value = 725; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::PointerType> { static constexpr size_t value = 726; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::Property> { static constexpr size_t value = 727; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Csharp::TypeLocation> { static constexpr size_t value = 728; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Yaml::YamlDataAvailable> { static constexpr size_t value = 729; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::CxxNameLowerCase> { static constexpr size_t value = 730; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::FlowNameLowerCase> { static constexpr size_t value = 731; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::HackNameLowerCase> { static constexpr size_t value = 732; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::PythonNameLowerCase> { static constexpr size_t value = 733; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Types::RangeSpanContains> { static constexpr size_t value = 734; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Scip::LsifKindToKind> { static constexpr size_t value = 735; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Scip::FileXLangSymbolRefs> { static constexpr size_t value = 736; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::NonImportPythonDeclarationKind> { static constexpr size_t value = 737; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::NonImportPythonDeclarationInfo> { static constexpr size_t value = 738; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::ConvertLabel> { static constexpr size_t value = 739; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Pp::PpIncludeXRefLocations> { static constexpr size_t value = 740; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Lsif::LsifKindToKind> { static constexpr size_t value = 741; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackInheritedEntities> { static constexpr size_t value = 742; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackEnumInheritedMembers> { static constexpr size_t value = 743; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::FromHackVisibility> { static constexpr size_t value = 744; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowDocumentationSpan> { static constexpr size_t value = 745; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowDeclarationDocumentation> { static constexpr size_t value = 746; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::FromCxxVisibility> { static constexpr size_t value = 747; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityXMapVariableXRefDeclLocations> { static constexpr size_t value = 748; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationModifiers> { static constexpr size_t value = 749; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclVisibility> { static constexpr size_t value = 750; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclKind> { static constexpr size_t value = 751; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclInfo> { static constexpr size_t value = 752; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDataAvailable> { static constexpr size_t value = 753; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::IndexedFile> { static constexpr size_t value = 754; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityDataAvailable> { static constexpr size_t value = 755; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Scip::EntityInfo> { static constexpr size_t value = 756; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Scip::ScipEntityDocumentation> { static constexpr size_t value = 757; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Scip::ScipEntityLocation> { static constexpr size_t value = 758; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Scip::ScipEntityUses> { static constexpr size_t value = 759; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Scip::ScipFileEntityXRefLocations> { static constexpr size_t value = 760; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Scip::ScipResolveLocation> { static constexpr size_t value = 761; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonContainsChildEntity> { static constexpr size_t value = 762; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonContainsParentEntity> { static constexpr size_t value = 763; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityComments> { static constexpr size_t value = 764; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityInfo> { static constexpr size_t value = 765; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityKind> { static constexpr size_t value = 766; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityLocation> { static constexpr size_t value = 767; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityModuleName> { static constexpr size_t value = 768; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityUses> { static constexpr size_t value = 769; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonExtendsChildEntity> { static constexpr size_t value = 770; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonExtendsParentEntity> { static constexpr size_t value = 771; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonFileEntityXRefLocations> { static constexpr size_t value = 772; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonModifiers> { static constexpr size_t value = 773; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonResolveLocation> { static constexpr size_t value = 774; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonVisibility> { static constexpr size_t value = 775; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonAnnotation> { static constexpr size_t value = 776; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Pp::PPEntityLocation> { static constexpr size_t value = 777; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Pp::PpEntityInfo> { static constexpr size_t value = 778; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Pp::PpEntityKind> { static constexpr size_t value = 779; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Pp::PpEntityTraceXRefLocations> { static constexpr size_t value = 780; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Pp::PpEntityUses> { static constexpr size_t value = 781; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Pp::PpFileEntityXRefLocations> { static constexpr size_t value = 782; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Pp::PpResolveLocation> { static constexpr size_t value = 783; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Pp::PpResolveTraceLocation> { static constexpr size_t value = 784; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Lsif::EntityInfo> { static constexpr size_t value = 785; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Lsif::LsifEntityLocation> { static constexpr size_t value = 786; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Lsif::LsifEntityModuleName> { static constexpr size_t value = 787; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Lsif::LsifEntityUses> { static constexpr size_t value = 788; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Lsif::LsifFileEntityXRefLocations> { static constexpr size_t value = 789; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Lsif::LsifResolveLocation> { static constexpr size_t value = 790; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinContainsChildEntity> { static constexpr size_t value = 791; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinContainsParentEntity> { static constexpr size_t value = 792; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinEntityKind> { static constexpr size_t value = 793; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinEntityLocation> { static constexpr size_t value = 794; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinEntityUses> { static constexpr size_t value = 795; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinExtendsParentEntity> { static constexpr size_t value = 796; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinFileEntityXRefLocations> { static constexpr size_t value = 797; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinResolveLocation> { static constexpr size_t value = 798; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaContainsChildEntity> { static constexpr size_t value = 799; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaContainsParentEntity> { static constexpr size_t value = 800; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaEntityDocumentation> { static constexpr size_t value = 801; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaEntityKind> { static constexpr size_t value = 802; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaEntityLocation> { static constexpr size_t value = 803; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaEntityUses> { static constexpr size_t value = 804; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaExtendsChildEntity> { static constexpr size_t value = 805; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaExtendsParentEntity> { static constexpr size_t value = 806; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaModifiers> { static constexpr size_t value = 807; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaResolveLocation> { static constexpr size_t value = 808; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaVisibility> { static constexpr size_t value = 809; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavalFileEntityXRefLocations> { static constexpr size_t value = 810; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Java::JavaAnnotation> { static constexpr size_t value = 811; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellContainsChildEntity> { static constexpr size_t value = 812; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellContainsParentEntity> { static constexpr size_t value = 813; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellEntityLocation> { static constexpr size_t value = 814; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellEntityUses> { static constexpr size_t value = 815; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellFileEntityXRefLocations> { static constexpr size_t value = 816; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellResolveLocation> { static constexpr size_t value = 817; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hs::SearchByLowerCaseName> { static constexpr size_t value = 818; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Hs::SearchByName> { static constexpr size_t value = 819; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::EntityHasHideFromDocsAttr> { static constexpr size_t value = 820; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackContainsChildEntity> { static constexpr size_t value = 821; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackContainsParentEntity> { static constexpr size_t value = 822; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityDocumentation> { static constexpr size_t value = 823; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityInfo> { static constexpr size_t value = 824; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityKind> { static constexpr size_t value = 825; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityLocation> { static constexpr size_t value = 826; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityModuleName> { static constexpr size_t value = 827; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackEntitySource> { static constexpr size_t value = 828; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityUses> { static constexpr size_t value = 829; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackExtendsChildEntity> { static constexpr size_t value = 830; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackExtendsParentEntity> { static constexpr size_t value = 831; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackExtendsParentEntityConcise> { static constexpr size_t value = 832; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackFileEntityXRefLocations> { static constexpr size_t value = 833; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackFileEntityXRefSpans> { static constexpr size_t value = 834; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackModifiers> { static constexpr size_t value = 835; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackRequiredConstraint> { static constexpr size_t value = 836; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackResolveLocation> { static constexpr size_t value = 837; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackVisibility> { static constexpr size_t value = 838; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackAnnotation> { static constexpr size_t value = 839; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Graphql::GraphQLEntityKind> { static constexpr size_t value = 840; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Graphql::GraphQLEntityLocation> { static constexpr size_t value = 841; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Graphql::GraphQLEntityUses> { static constexpr size_t value = 842; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Graphql::GraphQLFileEntityXRefLocations> { static constexpr size_t value = 843; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Graphql::GraphQLResolveLocation> { static constexpr size_t value = 844; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowContainsChildEntity> { static constexpr size_t value = 845; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowContainsParentEntity> { static constexpr size_t value = 846; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowEntityDocumentation> { static constexpr size_t value = 847; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowEntityKind> { static constexpr size_t value = 848; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowEntityLocation> { static constexpr size_t value = 849; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowEntityModuleName> { static constexpr size_t value = 850; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowEntityUses> { static constexpr size_t value = 851; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowFileEntityXRefLocations> { static constexpr size_t value = 852; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowFileImportDeclEntityXRefLocations> { static constexpr size_t value = 853; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowFileReferenceEntityXRefLocations> { static constexpr size_t value = 854; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Flow::FlowResolveLocation> { static constexpr size_t value = 855; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Fbthrift::FbthriftEntityDocumentation> { static constexpr size_t value = 856; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Fbthrift::FbthriftEntityUses> { static constexpr size_t value = 857; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftContainsChildEntity> { static constexpr size_t value = 858; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftContainsParentEntity> { static constexpr size_t value = 859; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftEntityKind> { static constexpr size_t value = 860; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftEntityLocation> { static constexpr size_t value = 861; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftExtendsChildEntity> { static constexpr size_t value = 862; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftExtendsParentEntity> { static constexpr size_t value = 863; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftFileEntityXRefLocations> { static constexpr size_t value = 864; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftResolveLocation> { static constexpr size_t value = 865; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangEntityDocumentation> { static constexpr size_t value = 866; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangEntityInfo> { static constexpr size_t value = 867; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangEntityKind> { static constexpr size_t value = 868; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangEntityLocation> { static constexpr size_t value = 869; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangEntityUses> { static constexpr size_t value = 870; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangFileEntityXRefLocations> { static constexpr size_t value = 871; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangResolveLocation> { static constexpr size_t value = 872; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Erlang::SearchByFQN> { static constexpr size_t value = 873; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Erlang::SearchByName> { static constexpr size_t value = 874; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Dataswarm::DataswarmFileEntityXRefLocations> { static constexpr size_t value = 875; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxContainsChildEntity> { static constexpr size_t value = 876; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxContainsParentEntity> { static constexpr size_t value = 877; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclToDefXRefTargetLocation> { static constexpr size_t value = 878; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationContainsChild> { static constexpr size_t value = 879; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationContainsParent> { static constexpr size_t value = 880; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationExtendsChild> { static constexpr size_t value = 881; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationExtendsParent> { static constexpr size_t value = 882; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationSource> { static constexpr size_t value = 883; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefToDeclFamilyXRefTargetLocation> { static constexpr size_t value = 884; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityDocumentation> { static constexpr size_t value = 885; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityInfo> { static constexpr size_t value = 886; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityKind> { static constexpr size_t value = 887; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityLocation> { static constexpr size_t value = 888; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityMangledNameHash> { static constexpr size_t value = 889; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntitySource> { static constexpr size_t value = 890; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityUSR> { static constexpr size_t value = 891; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityUses> { static constexpr size_t value = 892; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxExtendsChildEntity> { static constexpr size_t value = 893; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxExtendsParentEntity> { static constexpr size_t value = 894; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntitySpellingXRefLocations> { static constexpr size_t value = 895; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityTraceDeclToDefXRefLocations> { static constexpr size_t value = 896; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityXMapFixedXRefLocations> { static constexpr size_t value = 897; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityXMapVariableXRefDeclToDefs> { static constexpr size_t value = 898; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityXRefLocations> { static constexpr size_t value = 899; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFindDefinitionOfEntity> { static constexpr size_t value = 900; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxModifiers> { static constexpr size_t value = 901; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxNamespaceDeclarationContainsChild> { static constexpr size_t value = 902; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxResolveDeclarationToEntity> { static constexpr size_t value = 903; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxResolveLocation> { static constexpr size_t value = 904; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxResolveTraceLocation> { static constexpr size_t value = 905; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxVisibility> { static constexpr size_t value = 906; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxXRefTargetLocation> { static constexpr size_t value = 907; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::EntityToXRefTarget> { static constexpr size_t value = 908; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::SymbolToEntity> { static constexpr size_t value = 909; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::XRefTargetToEntity> { static constexpr size_t value = 910; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::CxxPreferDefinitions> { static constexpr size_t value = 911; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Kind::Cxx::SearchObjcInterface> { static constexpr size_t value = 912; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::DefinitionOfDecl> { static constexpr size_t value = 913; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::LookupNamespaceDefinition> { static constexpr size_t value = 914; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefinitionContainsChild> { static constexpr size_t value = 915; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefinitionContainsParent> { static constexpr size_t value = 916; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefinitionExtendsChild> { static constexpr size_t value = 917; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefinitionExtendsParent> { static constexpr size_t value = 918; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefinitionModifiers> { static constexpr size_t value = 919; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefnVisibility> { static constexpr size_t value = 920; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityDefinitionBase> { static constexpr size_t value = 921; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Cxx::DeclIsDefn> { static constexpr size_t value = 922; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Code::Cxx::DeclToDef> { static constexpr size_t value = 923; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxAnnotation> { static constexpr size_t value = 924; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Csharp::CSharpEntityKind> { static constexpr size_t value = 925; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Csharp::CSharpEntityLocation> { static constexpr size_t value = 926; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Csharp::CSharpEntityUses> { static constexpr size_t value = 927; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Csharp::CSharpFileEntityXRefLocations> { static constexpr size_t value = 928; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Csharp::CSharpResolveLocation> { static constexpr size_t value = 929; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Buck::BuckEntityKind> { static constexpr size_t value = 930; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Buck::BuckEntityLocation> { static constexpr size_t value = 931; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Buck::BuckEntityUses> { static constexpr size_t value = 932; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Buck::BuckFileEntityXRefLocations> { static constexpr size_t value = 933; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Buck::BuckResolveLocation> { static constexpr size_t value = 934; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Buck::SearchByFQN> { static constexpr size_t value = 935; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Buck::SearchDefinition> { static constexpr size_t value = 936; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Buck::SearchFile> { static constexpr size_t value = 937; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Code::EntityLanguageSCIP> { static constexpr size_t value = 938; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Code::EntityLanguageLSIF> { static constexpr size_t value = 939; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FunctionName> { static constexpr size_t value = 940; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::RecordDeclaration> { static constexpr size_t value = 941; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::DeclarationScope> { static constexpr size_t value = 942; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::EnumDeclarationByName> { static constexpr size_t value = 943; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FunctionDeclarationByNameScope> { static constexpr size_t value = 944; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::FunctionQName> { static constexpr size_t value = 945; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::QName> { static constexpr size_t value = 946; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::RecordDeclarationClass> { static constexpr size_t value = 947; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::RecordDeclarationStruct> { static constexpr size_t value = 948; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::RecordDeclarationUnion> { static constexpr size_t value = 949; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::TypeAliasDeclarationByName> { static constexpr size_t value = 950; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Cxx1::VariableDeclarationNonLocalByName> { static constexpr size_t value = 951; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Cxx::QueryToScopeCase> { static constexpr size_t value = 952; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Kind::Cxx::SearchClass> { static constexpr size_t value = 953; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Kind::Cxx::SearchEnum> { static constexpr size_t value = 954; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Kind::Cxx::SearchEnumerator> { static constexpr size_t value = 955; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Kind::Cxx::SearchFunction> { static constexpr size_t value = 956; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Kind::Cxx::SearchNamespace> { static constexpr size_t value = 957; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Kind::Cxx::SearchStruct> { static constexpr size_t value = 958; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Kind::Cxx::SearchTypeAlias> { static constexpr size_t value = 959; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Kind::Cxx::SearchUnion> { static constexpr size_t value = 960; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Kind::Cxx::SearchVariable> { static constexpr size_t value = 961; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::LookupDeclaration> { static constexpr size_t value = 962; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::LookupDefinition> { static constexpr size_t value = 963; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::LookupEnumerator> { static constexpr size_t value = 964; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionDeclaration> { static constexpr size_t value = 965; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionDefinition> { static constexpr size_t value = 966; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionSignatureDeclaration> { static constexpr size_t value = 967; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionSignatureDefinition> { static constexpr size_t value = 968; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionSignatureQualifierDeclaration> { static constexpr size_t value = 969; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionSignatureQualifierDefinition> { static constexpr size_t value = 970; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Fbthrift::FunctionSpecification> { static constexpr size_t value = 971; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::Type> { static constexpr size_t value = 972; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TranslationUnit> { static constexpr size_t value = 973; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetUses> { static constexpr size_t value = 974; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetSourcesBaseModule> { static constexpr size_t value = 975; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetSources> { static constexpr size_t value = 976; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetOuts> { static constexpr size_t value = 977; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetOut> { static constexpr size_t value = 978; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetMode> { static constexpr size_t value = 979; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetLocation> { static constexpr size_t value = 980; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetLinkWhole> { static constexpr size_t value = 981; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetIndexerName> { static constexpr size_t value = 982; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetIndexer> { static constexpr size_t value = 983; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetHash> { static constexpr size_t value = 984; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetCallByCallExpr> { static constexpr size_t value = 985; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetCall> { static constexpr size_t value = 986; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetByType> { static constexpr size_t value = 987; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetAttribute> { static constexpr size_t value = 988; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::Target> { static constexpr size_t value = 989; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::SourceFileLocation> { static constexpr size_t value = 990; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::SearchByLocalName> { static constexpr size_t value = 991; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::RuleKey> { static constexpr size_t value = 992; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::Platform> { static constexpr size_t value = 993; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::Owner> { static constexpr size_t value = 994; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::OutsTarget> { static constexpr size_t value = 995; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::OutputLabel> { static constexpr size_t value = 996; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::OutTarget> { static constexpr size_t value = 997; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::LocatorWithLabel> { static constexpr size_t value = 998; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::LocatorReverseDeps> { static constexpr size_t value = 999; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::LocatorReverseDep> { static constexpr size_t value = 1000; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::Locator> { static constexpr size_t value = 1001; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::LocalNameLowerCase> { static constexpr size_t value = 1002; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::LocalName> { static constexpr size_t value = 1003; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::Labels> { static constexpr size_t value = 1004; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::Label> { static constexpr size_t value = 1005; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::IndexerName> { static constexpr size_t value = 1006; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::FileXRefs> { static constexpr size_t value = 1007; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::FileToTarget> { static constexpr size_t value = 1008; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::FileTarget> { static constexpr size_t value = 1009; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::FileResolved> { static constexpr size_t value = 1010; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::FileEntity> { static constexpr size_t value = 1011; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::FileDefinition> { static constexpr size_t value = 1012; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::File> { static constexpr size_t value = 1013; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::FailureSources> { static constexpr size_t value = 1014; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::IndexFailureX> { static constexpr size_t value = 1015; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::DestinationUses> { static constexpr size_t value = 1016; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::TargetDependencies> { static constexpr size_t value = 1017; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::DefinitionLocation> { static constexpr size_t value = 1018; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::Definition> { static constexpr size_t value = 1019; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::Consumer> { static constexpr size_t value = 1020; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::CallExpr> { static constexpr size_t value = 1021; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::CallArgument> { static constexpr size_t value = 1022; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::AttributeName> { static constexpr size_t value = 1023; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::AttributeValue> { static constexpr size_t value = 1024; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Buck::ArgumentValue> { static constexpr size_t value = 1025; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Anglelang::TypeDecl> { static constexpr size_t value = 1026; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Anglelang::Name> { static constexpr size_t value = 1027; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Anglelang::Type> { static constexpr size_t value = 1028; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Anglelang::EvolveDecl> { static constexpr size_t value = 1029; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Anglelang::DerivingDecl> { static constexpr size_t value = 1030; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Anglelang::PredicateDecl> { static constexpr size_t value = 1031; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Anglelang::DeclarationLocation> { static constexpr size_t value = 1032; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Anglelang::DeclarationToName> { static constexpr size_t value = 1033; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Anglelang::SchemaDecl> { static constexpr size_t value = 1034; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Anglelang::TargetUses> { static constexpr size_t value = 1035; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Anglelang::FileXRefs> { static constexpr size_t value = 1036; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::ConvertCallArguments> { static constexpr size_t value = 1037; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::ConvertMaybeCallArguments> { static constexpr size_t value = 1038; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::ConvertCallArguments> { static constexpr size_t value = 1039; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::PythonFileCall> { static constexpr size_t value = 1040; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::ConvertArgument> { static constexpr size_t value = 1041; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Python::ConvertArgument> { static constexpr size_t value = 1042; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Code::EntityLanguage> { static constexpr size_t value = 1043; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityIdl> { static constexpr size_t value = 1044; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityIdl> { static constexpr size_t value = 1045; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Yaml::YamlFileEntityXLangXRefLocations> { static constexpr size_t value = 1046; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::ContainsChildEntity> { static constexpr size_t value = 1047; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::ContainsParentEntity> { static constexpr size_t value = 1048; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityComments> { static constexpr size_t value = 1049; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityInfo> { static constexpr size_t value = 1050; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityIsDefinition> { static constexpr size_t value = 1051; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityKind> { static constexpr size_t value = 1052; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityLocation> { static constexpr size_t value = 1053; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityModifiers> { static constexpr size_t value = 1054; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityModuleName> { static constexpr size_t value = 1055; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityReferences> { static constexpr size_t value = 1056; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntitySource> { static constexpr size_t value = 1057; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityToAnnotations> { static constexpr size_t value = 1058; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityUses> { static constexpr size_t value = 1059; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::EntityVisibility> { static constexpr size_t value = 1060; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::ExtendsChildEntity> { static constexpr size_t value = 1061; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::ExtendsParentEntity> { static constexpr size_t value = 1062; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::ExtendsParentEntityConcise> { static constexpr size_t value = 1063; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::FileCall> { static constexpr size_t value = 1064; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::FileEntityDigest> { static constexpr size_t value = 1065; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::FileEntityInfos> { static constexpr size_t value = 1066; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::FileEntityKinds> { static constexpr size_t value = 1067; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::FileEntityLocations> { static constexpr size_t value = 1068; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::FileEntityXRefInfos> { static constexpr size_t value = 1069; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::FileEntityXRefKinds> { static constexpr size_t value = 1070; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::FileEntityXRefLocations> { static constexpr size_t value = 1071; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::FileEntityXRefRangeSpans> { static constexpr size_t value = 1072; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::FindEntityDefinition> { static constexpr size_t value = 1073; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::GeneratedEntityToIdlEntity> { static constexpr size_t value = 1074; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::FileXRefsGenericEntities> { static constexpr size_t value = 1075; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::SearchRelatedEntities> { static constexpr size_t value = 1076; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::ReferencingEntity> { static constexpr size_t value = 1077; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::ResolveLocation> { static constexpr size_t value = 1078; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::SearchInheritedEntities> { static constexpr size_t value = 1079; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::SymbolToEntity> { static constexpr size_t value = 1080; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityIdl> { static constexpr size_t value = 1081; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Cxx::CxxIdlEntityUses> { static constexpr size_t value = 1082; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::ConvertCallee> { static constexpr size_t value = 1083; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::ConvertCalleeForFileCall> { static constexpr size_t value = 1084; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::ConvertStaticType> { static constexpr size_t value = 1085; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackFileCall> { static constexpr size_t value = 1086; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Hack::HackIdlEntityUses> { static constexpr size_t value = 1087; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Search::EntityLocationAndKind> { static constexpr size_t value = 1088; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Search::SearchByName> { static constexpr size_t value = 1089; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Search::SearchByScope> { static constexpr size_t value = 1090; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Dyn::EntityUsage> { static constexpr size_t value = 1091; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::AngleSearchByLowerCaseName> { static constexpr size_t value = 1092; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::AngleSearchByName> { static constexpr size_t value = 1093; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::BuckSearchByLocalNameFact> { static constexpr size_t value = 1094; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::BuckSearchByLowerCaseName> { static constexpr size_t value = 1095; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::BuckSearchByName> { static constexpr size_t value = 1096; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::CSharpSearchByLowerCaseName> { static constexpr size_t value = 1097; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::CSharpSearchByName> { static constexpr size_t value = 1098; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::CxxSearchByLowerCaseNameKindAndScopeFact> { static constexpr size_t value = 1099; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::CxxSearchByLowerCaseScopeAndKind> { static constexpr size_t value = 1100; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::CxxSearchByNameKindAndScopeFact> { static constexpr size_t value = 1101; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::CxxSearchByScopeAndKind> { static constexpr size_t value = 1102; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::ErlangSearchByLowerCaseName> { static constexpr size_t value = 1103; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::ErlangSearchByName> { static constexpr size_t value = 1104; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::FbthriftSearchByNameFact> { static constexpr size_t value = 1105; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::FlowSearchByLowerCaseNameKindAndScopeFact> { static constexpr size_t value = 1106; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::FlowSearchByLowerCaseScopeAndKind> { static constexpr size_t value = 1107; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::FlowSearchByNameKindAndScopeFact> { static constexpr size_t value = 1108; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::FlowSearchByScopeAndKind> { static constexpr size_t value = 1109; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::GraphQLSearchByLowerCaseName> { static constexpr size_t value = 1110; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::GraphQLSearchByName> { static constexpr size_t value = 1111; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::HackSearchByLowerCaseNameAndKind> { static constexpr size_t value = 1112; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::HackSearchByLowerCaseScopeAndKind> { static constexpr size_t value = 1113; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::HackSearchByNameAndKind> { static constexpr size_t value = 1114; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::HackSearchByNameKindWithNamespace> { static constexpr size_t value = 1115; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::HackSearchByNameKindWithQName> { static constexpr size_t value = 1116; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::HackSearchByScopeAndKind> { static constexpr size_t value = 1117; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::HackSearchByScopeWithNameKinds> { static constexpr size_t value = 1118; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::HsSearchByLowerCaseName> { static constexpr size_t value = 1119; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::HsSearchByName> { static constexpr size_t value = 1120; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::JavaSearchByLowerCaseName> { static constexpr size_t value = 1121; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::JavaSearchByLowerCaseScope> { static constexpr size_t value = 1122; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::JavaSearchByName> { static constexpr size_t value = 1123; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::JavaSearchByNameWithFact> { static constexpr size_t value = 1124; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::JavaSearchByScope> { static constexpr size_t value = 1125; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::JavaSearchByScopeWithName> { static constexpr size_t value = 1126; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::KotlinSearchByLowerCaseName> { static constexpr size_t value = 1127; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::KotlinSearchByLowerCaseScope> { static constexpr size_t value = 1128; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::KotlinSearchByName> { static constexpr size_t value = 1129; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::KotlinSearchByNameWithFact> { static constexpr size_t value = 1130; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::KotlinSearchByScope> { static constexpr size_t value = 1131; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::KotlinSearchByScopeWithName> { static constexpr size_t value = 1132; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::LsifSearchByLowerCaseName> { static constexpr size_t value = 1133; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::LsifSearchByName> { static constexpr size_t value = 1134; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::PpSearchByLowerCaseNameKind> { static constexpr size_t value = 1135; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::PpSearchByNameKind> { static constexpr size_t value = 1136; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::PythonSearchByLowerCaseNameKindAndScopeFact> { static constexpr size_t value = 1137; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::PythonSearchByLowerCaseScopeAndKind> { static constexpr size_t value = 1138; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::PythonSearchByNameKindAndScopeFact> { static constexpr size_t value = 1139; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::PythonSearchByScopeAndKind> { static constexpr size_t value = 1140; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::RustSearchByNameAndKind> { static constexpr size_t value = 1141; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::SearchByLowerCaseNameAndLanguage> { static constexpr size_t value = 1142; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::SearchByLowerCaseNameKindAndLanguage> { static constexpr size_t value = 1143; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::SearchByLowerCaseScope> { static constexpr size_t value = 1144; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::SearchByLowerCaseScopeAndKind> { static constexpr size_t value = 1145; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::SearchByNameAndLanguage> { static constexpr size_t value = 1146; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::SearchByNameKindAndLanguage> { static constexpr size_t value = 1147; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::SearchByScope> { static constexpr size_t value = 1148; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::SearchByScopeAndKind> { static constexpr size_t value = 1149; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::ThriftSearchByLowerCaseName> { static constexpr size_t value = 1150; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Code::ThriftSearchByName> { static constexpr size_t value = 1151; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Anglelang::AngleEntityLocation> { static constexpr size_t value = 1152; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Anglelang::AngleEntityUses> { static constexpr size_t value = 1153; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Anglelang::AngleFileEntityXRefLocations> { static constexpr size_t value = 1154; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Codemarkup::Anglelang::AngleResolveLocation> { static constexpr size_t value = 1155; };
template<> struct SCHEMA::index<facebook::glean::cpp::schema::Search::Anglelang::SearchByName> { static constexpr size_t value = 1156; };

template<> struct SCHEMA::predicate<0> { using type = facebook::glean::cpp::schema::Sys::Blob; };
template<> struct SCHEMA::predicate<1> { using type = facebook::glean::cpp::schema::Src::RangeContains; };
template<> struct SCHEMA::predicate<2> { using type = facebook::glean::cpp::schema::Src::IndexFailure; };
template<> struct SCHEMA::predicate<3> { using type = facebook::glean::cpp::schema::Src::FileLines; };
template<> struct SCHEMA::predicate<4> { using type = facebook::glean::cpp::schema::Src::FileLanguage; };
template<> struct SCHEMA::predicate<5> { using type = facebook::glean::cpp::schema::Src::FileDigest; };
template<> struct SCHEMA::predicate<6> { using type = facebook::glean::cpp::schema::Src::File; };
template<> struct SCHEMA::predicate<7> { using type = facebook::glean::cpp::schema::Src::ByteSpanContains; };
template<> struct SCHEMA::predicate<8> { using type = facebook::glean::cpp::schema::Search::Python::QueryToScopeCase; };
template<> struct SCHEMA::predicate<9> { using type = facebook::glean::cpp::schema::Search::Python::PythonNameCase; };
template<> struct SCHEMA::predicate<10> { using type = facebook::glean::cpp::schema::Search::Pp::SearchByName; };
template<> struct SCHEMA::predicate<11> { using type = facebook::glean::cpp::schema::Search::Java::QueryToScopeCase; };
template<> struct SCHEMA::predicate<12> { using type = facebook::glean::cpp::schema::Search::Java::NameCase; };
template<> struct SCHEMA::predicate<13> { using type = facebook::glean::cpp::schema::Search::Hack::QueryToScopeCase; };
template<> struct SCHEMA::predicate<14> { using type = facebook::glean::cpp::schema::Search::Hack::HackNameCase; };
template<> struct SCHEMA::predicate<15> { using type = facebook::glean::cpp::schema::Search::Hack::HackInAutoImportedNamespace; };
template<> struct SCHEMA::predicate<16> { using type = facebook::glean::cpp::schema::Search::Flow::TypeDeclarationAsDeclaration; };
template<> struct SCHEMA::predicate<17> { using type = facebook::glean::cpp::schema::Search::Flow::QueryToScopeCase; };
template<> struct SCHEMA::predicate<18> { using type = facebook::glean::cpp::schema::Search::Flow::FlowModuleNameCase; };
template<> struct SCHEMA::predicate<19> { using type = facebook::glean::cpp::schema::Search::Cxx::QueryToQNameCase; };
template<> struct SCHEMA::predicate<20> { using type = facebook::glean::cpp::schema::Search::Cxx::QueryToNSQNameCase; };
template<> struct SCHEMA::predicate<21> { using type = facebook::glean::cpp::schema::Search::Cxx::CxxRecordCase; };
template<> struct SCHEMA::predicate<22> { using type = facebook::glean::cpp::schema::Search::Cxx::CxxNamespaceCase; };
template<> struct SCHEMA::predicate<23> { using type = facebook::glean::cpp::schema::Search::Anglelang::NameLowerCase; };
template<> struct SCHEMA::predicate<24> { using type = facebook::glean::cpp::schema::Scip::SymbolName; };
template<> struct SCHEMA::predicate<25> { using type = facebook::glean::cpp::schema::Scip::SymbolDocumentation; };
template<> struct SCHEMA::predicate<26> { using type = facebook::glean::cpp::schema::Scip::SymbolDisplayName; };
template<> struct SCHEMA::predicate<27> { using type = facebook::glean::cpp::schema::Scip::Symbol; };
template<> struct SCHEMA::predicate<28> { using type = facebook::glean::cpp::schema::Scip::ReferenceTarget; };
template<> struct SCHEMA::predicate<29> { using type = facebook::glean::cpp::schema::Scip::Reference; };
template<> struct SCHEMA::predicate<30> { using type = facebook::glean::cpp::schema::Scip::LocalName; };
template<> struct SCHEMA::predicate<31> { using type = facebook::glean::cpp::schema::Scip::IsImplemented; };
template<> struct SCHEMA::predicate<32> { using type = facebook::glean::cpp::schema::Scip::IsImplementation; };
template<> struct SCHEMA::predicate<33> { using type = facebook::glean::cpp::schema::Scip::EntityDefinition; };
template<> struct SCHEMA::predicate<34> { using type = facebook::glean::cpp::schema::Scip::EntityLocation; };
template<> struct SCHEMA::predicate<35> { using type = facebook::glean::cpp::schema::Scip::EntityUses; };
template<> struct SCHEMA::predicate<36> { using type = facebook::glean::cpp::schema::Scip::FileEntityXRefLocation; };
template<> struct SCHEMA::predicate<37> { using type = facebook::glean::cpp::schema::Scip::ResolveLocation; };
template<> struct SCHEMA::predicate<38> { using type = facebook::glean::cpp::schema::Scip::SearchBySymbol; };
template<> struct SCHEMA::predicate<39> { using type = facebook::glean::cpp::schema::Scip::Documentation; };
template<> struct SCHEMA::predicate<40> { using type = facebook::glean::cpp::schema::Scip::DisplayNameSymbol; };
template<> struct SCHEMA::predicate<41> { using type = facebook::glean::cpp::schema::Scip::DisplayName; };
template<> struct SCHEMA::predicate<42> { using type = facebook::glean::cpp::schema::Scip::DefinitionUses; };
template<> struct SCHEMA::predicate<43> { using type = facebook::glean::cpp::schema::Scip::DefinitionName; };
template<> struct SCHEMA::predicate<44> { using type = facebook::glean::cpp::schema::Scip::DefinitionDocumentation; };
template<> struct SCHEMA::predicate<45> { using type = facebook::glean::cpp::schema::Scip::Definition; };
template<> struct SCHEMA::predicate<46> { using type = facebook::glean::cpp::schema::Python::Branches::Root; };
template<> struct SCHEMA::predicate<47> { using type = facebook::glean::cpp::schema::Python::Branches::FileToRoot; };
template<> struct SCHEMA::predicate<48> { using type = facebook::glean::cpp::schema::Python::Branches::DirectXRefByFile; };
template<> struct SCHEMA::predicate<49> { using type = facebook::glean::cpp::schema::Python::XRefsViaNameByTarget; };
template<> struct SCHEMA::predicate<50> { using type = facebook::glean::cpp::schema::Python::XRefsViaName; };
template<> struct SCHEMA::predicate<51> { using type = facebook::glean::cpp::schema::Python::XRefsViaNameByFile; };
template<> struct SCHEMA::predicate<52> { using type = facebook::glean::cpp::schema::Python::VariableDeclaration; };
template<> struct SCHEMA::predicate<53> { using type = facebook::glean::cpp::schema::Python::VariableBySName; };
template<> struct SCHEMA::predicate<54> { using type = facebook::glean::cpp::schema::Python::Type; };
template<> struct SCHEMA::predicate<55> { using type = facebook::glean::cpp::schema::Python::StringLiteral; };
template<> struct SCHEMA::predicate<56> { using type = facebook::glean::cpp::schema::Python::SearchVariableByName; };
template<> struct SCHEMA::predicate<57> { using type = facebook::glean::cpp::schema::Python::SearchVariableByLowerCaseName; };
template<> struct SCHEMA::predicate<58> { using type = facebook::glean::cpp::schema::Python::SearchModuleByName; };
template<> struct SCHEMA::predicate<59> { using type = facebook::glean::cpp::schema::Python::SearchModuleByLowerCaseName; };
template<> struct SCHEMA::predicate<60> { using type = facebook::glean::cpp::schema::Python::SearchMethodByName; };
template<> struct SCHEMA::predicate<61> { using type = facebook::glean::cpp::schema::Python::SearchMethodByLowerCaseName; };
template<> struct SCHEMA::predicate<62> { using type = facebook::glean::cpp::schema::Python::SearchFunctionByName; };
template<> struct SCHEMA::predicate<63> { using type = facebook::glean::cpp::schema::Python::SearchFunctionByLowerCaseName; };
template<> struct SCHEMA::predicate<64> { using type = facebook::glean::cpp::schema::Python::SearchFieldByName; };
template<> struct SCHEMA::predicate<65> { using type = facebook::glean::cpp::schema::Python::SearchFieldByLowerCaseName; };
template<> struct SCHEMA::predicate<66> { using type = facebook::glean::cpp::schema::Python::SearchClassByName; };
template<> struct SCHEMA::predicate<67> { using type = facebook::glean::cpp::schema::Python::SearchClassByLowerCaseName; };
template<> struct SCHEMA::predicate<68> { using type = facebook::glean::cpp::schema::Python::SNameToName; };
template<> struct SCHEMA::predicate<69> { using type = facebook::glean::cpp::schema::Python::SName; };
template<> struct SCHEMA::predicate<70> { using type = facebook::glean::cpp::schema::Python::ResolveOriginalName; };
template<> struct SCHEMA::predicate<71> { using type = facebook::glean::cpp::schema::Python::NameToSName; };
template<> struct SCHEMA::predicate<72> { using type = facebook::glean::cpp::schema::Python::Name; };
template<> struct SCHEMA::predicate<73> { using type = facebook::glean::cpp::schema::Python::ModuleDefinition; };
template<> struct SCHEMA::predicate<74> { using type = facebook::glean::cpp::schema::Python::ModuleBySName; };
template<> struct SCHEMA::predicate<75> { using type = facebook::glean::cpp::schema::Python::Module; };
template<> struct SCHEMA::predicate<76> { using type = facebook::glean::cpp::schema::Python::MethodOverrides; };
template<> struct SCHEMA::predicate<77> { using type = facebook::glean::cpp::schema::Python::MethodOverriden; };
template<> struct SCHEMA::predicate<78> { using type = facebook::glean::cpp::schema::Python::MethodByLocalNameStr; };
template<> struct SCHEMA::predicate<79> { using type = facebook::glean::cpp::schema::Python::ImportStatementByAsSName; };
template<> struct SCHEMA::predicate<80> { using type = facebook::glean::cpp::schema::Python::ImportStatementByAsName; };
template<> struct SCHEMA::predicate<81> { using type = facebook::glean::cpp::schema::Python::ImportStatement; };
template<> struct SCHEMA::predicate<82> { using type = facebook::glean::cpp::schema::Python::ImportStarsByFile; };
template<> struct SCHEMA::predicate<83> { using type = facebook::glean::cpp::schema::Python::ImportStarStatement; };
template<> struct SCHEMA::predicate<84> { using type = facebook::glean::cpp::schema::Python::ImportStarLocation; };
template<> struct SCHEMA::predicate<85> { using type = facebook::glean::cpp::schema::Python::FunctionDeclaration; };
template<> struct SCHEMA::predicate<86> { using type = facebook::glean::cpp::schema::Python::FunctionBySName; };
template<> struct SCHEMA::predicate<87> { using type = facebook::glean::cpp::schema::Python::DerivedClassToBase; };
template<> struct SCHEMA::predicate<88> { using type = facebook::glean::cpp::schema::Python::DefinitionLocation; };
template<> struct SCHEMA::predicate<89> { using type = facebook::glean::cpp::schema::Python::DefinitionsByFile; };
template<> struct SCHEMA::predicate<90> { using type = facebook::glean::cpp::schema::Python::IsTopLevelDefinition; };
template<> struct SCHEMA::predicate<91> { using type = facebook::glean::cpp::schema::Python::FunctionDefinition; };
template<> struct SCHEMA::predicate<92> { using type = facebook::glean::cpp::schema::Python::VariableDefinition; };
template<> struct SCHEMA::predicate<93> { using type = facebook::glean::cpp::schema::Python::DeclarationDefinition; };
template<> struct SCHEMA::predicate<94> { using type = facebook::glean::cpp::schema::Python::DeclarationDocstring; };
template<> struct SCHEMA::predicate<95> { using type = facebook::glean::cpp::schema::Python::DeclarationLocation; };
template<> struct SCHEMA::predicate<96> { using type = facebook::glean::cpp::schema::Python::DeclarationReference; };
template<> struct SCHEMA::predicate<97> { using type = facebook::glean::cpp::schema::Python::DeclarationToName; };
template<> struct SCHEMA::predicate<98> { using type = facebook::glean::cpp::schema::Python::DeclarationUses; };
template<> struct SCHEMA::predicate<99> { using type = facebook::glean::cpp::schema::Python::DeclarationWithLocalName; };
template<> struct SCHEMA::predicate<100> { using type = facebook::glean::cpp::schema::Python::DeclarationWithName; };
template<> struct SCHEMA::predicate<101> { using type = facebook::glean::cpp::schema::Python::DeclarationWithSName; };
template<> struct SCHEMA::predicate<102> { using type = facebook::glean::cpp::schema::Python::DeclarationsByFile; };
template<> struct SCHEMA::predicate<103> { using type = facebook::glean::cpp::schema::Python::DefinitionDeclaration; };
template<> struct SCHEMA::predicate<104> { using type = facebook::glean::cpp::schema::Python::DirectXRefsByFile; };
template<> struct SCHEMA::predicate<105> { using type = facebook::glean::cpp::schema::Python::IsAbstract; };
template<> struct SCHEMA::predicate<106> { using type = facebook::glean::cpp::schema::Python::IsTopLevelDeclaration; };
template<> struct SCHEMA::predicate<107> { using type = facebook::glean::cpp::schema::Python::NonImportDeclaration; };
template<> struct SCHEMA::predicate<108> { using type = facebook::glean::cpp::schema::Python::SNameWithDeclaration; };
template<> struct SCHEMA::predicate<109> { using type = facebook::glean::cpp::schema::Yaml::XRefsByFile; };
template<> struct SCHEMA::predicate<110> { using type = facebook::glean::cpp::schema::Python::Contains; };
template<> struct SCHEMA::predicate<111> { using type = facebook::glean::cpp::schema::Python::ContainingTopLevelDeclaration; };
template<> struct SCHEMA::predicate<112> { using type = facebook::glean::cpp::schema::Python::ContainedByTopLevelDeclaration; };
template<> struct SCHEMA::predicate<113> { using type = facebook::glean::cpp::schema::Python::ContainedBy; };
template<> struct SCHEMA::predicate<114> { using type = facebook::glean::cpp::schema::Python::ClassDefinition; };
template<> struct SCHEMA::predicate<115> { using type = facebook::glean::cpp::schema::Python::ClassDeclaration; };
template<> struct SCHEMA::predicate<116> { using type = facebook::glean::cpp::schema::Python::ClassBySName; };
template<> struct SCHEMA::predicate<117> { using type = facebook::glean::cpp::schema::Python::CalleeToCaller; };
template<> struct SCHEMA::predicate<118> { using type = facebook::glean::cpp::schema::Python::BaseClassToDerived; };
template<> struct SCHEMA::predicate<119> { using type = facebook::glean::cpp::schema::Python::FileCall; };
template<> struct SCHEMA::predicate<120> { using type = facebook::glean::cpp::schema::Pp1::Use; };
template<> struct SCHEMA::predicate<121> { using type = facebook::glean::cpp::schema::Pp1::Undef; };
template<> struct SCHEMA::predicate<122> { using type = facebook::glean::cpp::schema::Pp1::Macro; };
template<> struct SCHEMA::predicate<123> { using type = facebook::glean::cpp::schema::Pp1::Include; };
template<> struct SCHEMA::predicate<124> { using type = facebook::glean::cpp::schema::Pp1::DefineUse; };
template<> struct SCHEMA::predicate<125> { using type = facebook::glean::cpp::schema::Pp1::DefineLowerCase; };
template<> struct SCHEMA::predicate<126> { using type = facebook::glean::cpp::schema::Pp1::Define; };
template<> struct SCHEMA::predicate<127> { using type = facebook::glean::cpp::schema::Scip::Metadata; };
template<> struct SCHEMA::predicate<128> { using type = facebook::glean::cpp::schema::Scip::EntityKind; };
template<> struct SCHEMA::predicate<129> { using type = facebook::glean::cpp::schema::Scip::SearchByNameKind; };
template<> struct SCHEMA::predicate<130> { using type = facebook::glean::cpp::schema::Scip::SymbolKind; };
template<> struct SCHEMA::predicate<131> { using type = facebook::glean::cpp::schema::Lsif::Types::ToSrcRange; };
template<> struct SCHEMA::predicate<132> { using type = facebook::glean::cpp::schema::Scip::DefinitionLocation; };
template<> struct SCHEMA::predicate<133> { using type = facebook::glean::cpp::schema::Scip::FileRange; };
template<> struct SCHEMA::predicate<134> { using type = facebook::glean::cpp::schema::Scip::FileXLangSymbolRef; };
template<> struct SCHEMA::predicate<135> { using type = facebook::glean::cpp::schema::Scip::ReferenceLocation; };
template<> struct SCHEMA::predicate<136> { using type = facebook::glean::cpp::schema::Scip::FileLanguage; };
template<> struct SCHEMA::predicate<137> { using type = facebook::glean::cpp::schema::Scip::TagDefinition; };
template<> struct SCHEMA::predicate<138> { using type = facebook::glean::cpp::schema::Lsif::Types::FromSrcRange; };
template<> struct SCHEMA::predicate<139> { using type = facebook::glean::cpp::schema::Lsif::Reference; };
template<> struct SCHEMA::predicate<140> { using type = facebook::glean::cpp::schema::Lsif::Range; };
template<> struct SCHEMA::predicate<141> { using type = facebook::glean::cpp::schema::Lsif::ProjectDocument; };
template<> struct SCHEMA::predicate<142> { using type = facebook::glean::cpp::schema::Lsif::Project; };
template<> struct SCHEMA::predicate<143> { using type = facebook::glean::cpp::schema::Lsif::PackageInformation; };
template<> struct SCHEMA::predicate<144> { using type = facebook::glean::cpp::schema::Lsif::NameLowerCase; };
template<> struct SCHEMA::predicate<145> { using type = facebook::glean::cpp::schema::Lsif::NameDefinition; };
template<> struct SCHEMA::predicate<146> { using type = facebook::glean::cpp::schema::Lsif::Name; };
template<> struct SCHEMA::predicate<147> { using type = facebook::glean::cpp::schema::Lsif::MonikerSymbolKind; };
template<> struct SCHEMA::predicate<148> { using type = facebook::glean::cpp::schema::Lsif::MonikerScheme; };
template<> struct SCHEMA::predicate<149> { using type = facebook::glean::cpp::schema::Lsif::MonikerId; };
template<> struct SCHEMA::predicate<150> { using type = facebook::glean::cpp::schema::Lsif::MonikerDefinition; };
template<> struct SCHEMA::predicate<151> { using type = facebook::glean::cpp::schema::Lsif::Moniker; };
template<> struct SCHEMA::predicate<152> { using type = facebook::glean::cpp::schema::Lsif::Metadata; };
template<> struct SCHEMA::predicate<153> { using type = facebook::glean::cpp::schema::Lsif::HoverText; };
template<> struct SCHEMA::predicate<154> { using type = facebook::glean::cpp::schema::Lsif::HoverContent; };
template<> struct SCHEMA::predicate<155> { using type = facebook::glean::cpp::schema::Lsif::EntityDefinition; };
template<> struct SCHEMA::predicate<156> { using type = facebook::glean::cpp::schema::Lsif::EntityKind; };
template<> struct SCHEMA::predicate<157> { using type = facebook::glean::cpp::schema::Lsif::EntityLocation; };
template<> struct SCHEMA::predicate<158> { using type = facebook::glean::cpp::schema::Lsif::EntityUses; };
template<> struct SCHEMA::predicate<159> { using type = facebook::glean::cpp::schema::Lsif::FileEntityXRefLocation; };
template<> struct SCHEMA::predicate<160> { using type = facebook::glean::cpp::schema::Lsif::ResolveLocation; };
template<> struct SCHEMA::predicate<161> { using type = facebook::glean::cpp::schema::Lsif::SearchByExactLocation; };
template<> struct SCHEMA::predicate<162> { using type = facebook::glean::cpp::schema::Lsif::SearchByExactLocationAndName; };
template<> struct SCHEMA::predicate<163> { using type = facebook::glean::cpp::schema::Lsif::SearchByMoniker; };
template<> struct SCHEMA::predicate<164> { using type = facebook::glean::cpp::schema::Lsif::SearchByName; };
template<> struct SCHEMA::predicate<165> { using type = facebook::glean::cpp::schema::Lsif::SearchNonLocalByLocation; };
template<> struct SCHEMA::predicate<166> { using type = facebook::glean::cpp::schema::Lsif::TagDefinition; };
template<> struct SCHEMA::predicate<167> { using type = facebook::glean::cpp::schema::Lsif::Document; };
template<> struct SCHEMA::predicate<168> { using type = facebook::glean::cpp::schema::Lsif::DefinitionUse; };
template<> struct SCHEMA::predicate<169> { using type = facebook::glean::cpp::schema::Lsif::DefinitionMoniker; };
template<> struct SCHEMA::predicate<170> { using type = facebook::glean::cpp::schema::Lsif::DefinitionLocation; };
template<> struct SCHEMA::predicate<171> { using type = facebook::glean::cpp::schema::Lsif::DefinitionKind; };
template<> struct SCHEMA::predicate<172> { using type = facebook::glean::cpp::schema::Lsif::DefinitionHover; };
template<> struct SCHEMA::predicate<173> { using type = facebook::glean::cpp::schema::Lsif::Definition; };
template<> struct SCHEMA::predicate<174> { using type = facebook::glean::cpp::schema::Lsif::Declaration; };
template<> struct SCHEMA::predicate<175> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::VariableParent; };
template<> struct SCHEMA::predicate<176> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::VariableDeclaration; };
template<> struct SCHEMA::predicate<177> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::TypeArg; };
template<> struct SCHEMA::predicate<178> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::Type; };
template<> struct SCHEMA::predicate<179> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::DeclarationLocation; };
template<> struct SCHEMA::predicate<180> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::DeclarationFileLocation; };
template<> struct SCHEMA::predicate<181> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::ExtendsDeclaration; };
template<> struct SCHEMA::predicate<182> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::FileDeclarations; };
template<> struct SCHEMA::predicate<183> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::MethodDeclaration; };
template<> struct SCHEMA::predicate<184> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::ParentDeclaration; };
template<> struct SCHEMA::predicate<185> { using type = facebook::glean::cpp::schema::Search::Kotlin::SearchByQName; };
template<> struct SCHEMA::predicate<186> { using type = facebook::glean::cpp::schema::Symbolid::Kotlin::LookupDeclaration; };
template<> struct SCHEMA::predicate<187> { using type = facebook::glean::cpp::schema::Symbolid::Kotlin::LookupMethodDeclaration; };
template<> struct SCHEMA::predicate<188> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::ContainsDeclaration; };
template<> struct SCHEMA::predicate<189> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::ClassMember; };
template<> struct SCHEMA::predicate<190> { using type = facebook::glean::cpp::schema::Kotlin::Alpha::ClassDeclaration; };
template<> struct SCHEMA::predicate<191> { using type = facebook::glean::cpp::schema::Javakotlin::Alpha::Type; };
template<> struct SCHEMA::predicate<192> { using type = facebook::glean::cpp::schema::Javakotlin::Alpha::QName; };
template<> struct SCHEMA::predicate<193> { using type = facebook::glean::cpp::schema::Javakotlin::Alpha::Path; };
template<> struct SCHEMA::predicate<194> { using type = facebook::glean::cpp::schema::Javakotlin::Alpha::NameLowerCase; };
template<> struct SCHEMA::predicate<195> { using type = facebook::glean::cpp::schema::Javakotlin::Alpha::Name; };
template<> struct SCHEMA::predicate<196> { using type = facebook::glean::cpp::schema::Javakotlin::Alpha::MethodName; };
template<> struct SCHEMA::predicate<197> { using type = facebook::glean::cpp::schema::Java::Alpha::XRefFile; };
template<> struct SCHEMA::predicate<198> { using type = facebook::glean::cpp::schema::Java::Alpha::XRef; };
template<> struct SCHEMA::predicate<199> { using type = facebook::glean::cpp::schema::Java::Alpha::TypeVar; };
template<> struct SCHEMA::predicate<200> { using type = facebook::glean::cpp::schema::Java::Alpha::TypeParam; };
template<> struct SCHEMA::predicate<201> { using type = facebook::glean::cpp::schema::Java::Alpha::TypeOfTypeArgs; };
template<> struct SCHEMA::predicate<202> { using type = facebook::glean::cpp::schema::Java::Alpha::TypeArg; };
template<> struct SCHEMA::predicate<203> { using type = facebook::glean::cpp::schema::Java::Alpha::PrimitiveType; };
template<> struct SCHEMA::predicate<204> { using type = facebook::glean::cpp::schema::Java::Alpha::PackageDeclaration; };
template<> struct SCHEMA::predicate<205> { using type = facebook::glean::cpp::schema::Java::Alpha::ObjectType; };
template<> struct SCHEMA::predicate<206> { using type = facebook::glean::cpp::schema::Java::Alpha::ParameterDeclaration; };
template<> struct SCHEMA::predicate<207> { using type = facebook::glean::cpp::schema::Java::Alpha::InterfaceInheritance; };
template<> struct SCHEMA::predicate<208> { using type = facebook::glean::cpp::schema::Java::Alpha::Inheritance; };
template<> struct SCHEMA::predicate<209> { using type = facebook::glean::cpp::schema::Java::Alpha::ImportDeclaration; };
template<> struct SCHEMA::predicate<210> { using type = facebook::glean::cpp::schema::Java::Alpha::FileXRefs; };
template<> struct SCHEMA::predicate<211> { using type = facebook::glean::cpp::schema::Java::Alpha::ExecutableDefnLocation; };
template<> struct SCHEMA::predicate<212> { using type = facebook::glean::cpp::schema::Java::Alpha::LocalDeclaration; };
template<> struct SCHEMA::predicate<213> { using type = facebook::glean::cpp::schema::Java::Alpha::DefinitionLocation; };
template<> struct SCHEMA::predicate<214> { using type = facebook::glean::cpp::schema::Java::Alpha::EnumDeclaration; };
template<> struct SCHEMA::predicate<215> { using type = facebook::glean::cpp::schema::Java::Alpha::FieldDeclaration; };
template<> struct SCHEMA::predicate<216> { using type = facebook::glean::cpp::schema::Java::Alpha::InterfaceDeclaration; };
template<> struct SCHEMA::predicate<217> { using type = facebook::glean::cpp::schema::Java::Alpha::MethodDeclaration; };
template<> struct SCHEMA::predicate<218> { using type = facebook::glean::cpp::schema::Java::Alpha::DeclarationAnnotations; };
template<> struct SCHEMA::predicate<219> { using type = facebook::glean::cpp::schema::Java::Alpha::DeclarationComment; };
template<> struct SCHEMA::predicate<220> { using type = facebook::glean::cpp::schema::Java::Alpha::DeclarationLocation; };
template<> struct SCHEMA::predicate<221> { using type = facebook::glean::cpp::schema::Java::Alpha::DeclarationType; };
template<> struct SCHEMA::predicate<222> { using type = facebook::glean::cpp::schema::Java::Alpha::DeclarationUses; };
template<> struct SCHEMA::predicate<223> { using type = facebook::glean::cpp::schema::Java::Alpha::DeclarationXRefTarget; };
template<> struct SCHEMA::predicate<224> { using type = facebook::glean::cpp::schema::Java::Alpha::ExtendedByDeclaration; };
template<> struct SCHEMA::predicate<225> { using type = facebook::glean::cpp::schema::Java::Alpha::ExtendsDeclaration; };
template<> struct SCHEMA::predicate<226> { using type = facebook::glean::cpp::schema::Java::Alpha::FileDeclarations; };
template<> struct SCHEMA::predicate<227> { using type = facebook::glean::cpp::schema::Java::Alpha::ParentDeclaration; };
template<> struct SCHEMA::predicate<228> { using type = facebook::glean::cpp::schema::Java::Alpha::QNameToDefinition; };
template<> struct SCHEMA::predicate<229> { using type = facebook::glean::cpp::schema::Java::Alpha::XRefOfType; };
template<> struct SCHEMA::predicate<230> { using type = facebook::glean::cpp::schema::Java::Alpha::XRefTargetDeclaration; };
template<> struct SCHEMA::predicate<231> { using type = facebook::glean::cpp::schema::Search::Java::SearchByQName; };
template<> struct SCHEMA::predicate<232> { using type = facebook::glean::cpp::schema::Symbolid::Java::LookupDeclaration; };
template<> struct SCHEMA::predicate<233> { using type = facebook::glean::cpp::schema::Symbolid::Java::LookupMethodDeclaration; };
template<> struct SCHEMA::predicate<234> { using type = facebook::glean::cpp::schema::Java::Alpha::DeclOfExecutableDefn; };
template<> struct SCHEMA::predicate<235> { using type = facebook::glean::cpp::schema::Java::Alpha::DeclOfDefn; };
template<> struct SCHEMA::predicate<236> { using type = facebook::glean::cpp::schema::Java::Alpha::ContainsDeclaration; };
template<> struct SCHEMA::predicate<237> { using type = facebook::glean::cpp::schema::Java::Alpha::ConstructorDeclaration; };
template<> struct SCHEMA::predicate<238> { using type = facebook::glean::cpp::schema::Java::Alpha::ClassDeclaration; };
template<> struct SCHEMA::predicate<239> { using type = facebook::glean::cpp::schema::Java::Alpha::Type; };
template<> struct SCHEMA::predicate<240> { using type = facebook::glean::cpp::schema::Java::Alpha::ArrayType; };
template<> struct SCHEMA::predicate<241> { using type = facebook::glean::cpp::schema::Java::Alpha::Annotation; };
template<> struct SCHEMA::predicate<242> { using type = facebook::glean::cpp::schema::Java::Alpha::AnnotatedClass; };
template<> struct SCHEMA::predicate<243> { using type = facebook::glean::cpp::schema::Indexer::Config; };
template<> struct SCHEMA::predicate<244> { using type = facebook::glean::cpp::schema::Hs::ValBind; };
template<> struct SCHEMA::predicate<245> { using type = facebook::glean::cpp::schema::Hs::UnitName; };
template<> struct SCHEMA::predicate<246> { using type = facebook::glean::cpp::schema::Hs::TypeSynDecl; };
template<> struct SCHEMA::predicate<247> { using type = facebook::glean::cpp::schema::Hs::TypeFamilyDecl; };
template<> struct SCHEMA::predicate<248> { using type = facebook::glean::cpp::schema::Hs::TyVarBind; };
template<> struct SCHEMA::predicate<249> { using type = facebook::glean::cpp::schema::Hs::TyCon; };
template<> struct SCHEMA::predicate<250> { using type = facebook::glean::cpp::schema::Hs::SourceModule; };
template<> struct SCHEMA::predicate<251> { using type = facebook::glean::cpp::schema::Hs::SigDecl; };
template<> struct SCHEMA::predicate<252> { using type = facebook::glean::cpp::schema::Hs::XRef; };
template<> struct SCHEMA::predicate<253> { using type = facebook::glean::cpp::schema::Hs::RecordFieldDecl; };
template<> struct SCHEMA::predicate<254> { using type = facebook::glean::cpp::schema::Hs::PatSynDecl; };
template<> struct SCHEMA::predicate<255> { using type = facebook::glean::cpp::schema::Hs::PatBind; };
template<> struct SCHEMA::predicate<256> { using type = facebook::glean::cpp::schema::Hs::OccNameLowerCase; };
template<> struct SCHEMA::predicate<257> { using type = facebook::glean::cpp::schema::Hs::OccName; };
template<> struct SCHEMA::predicate<258> { using type = facebook::glean::cpp::schema::Hs::Name; };
template<> struct SCHEMA::predicate<259> { using type = facebook::glean::cpp::schema::Hs::ModuleSource; };
template<> struct SCHEMA::predicate<260> { using type = facebook::glean::cpp::schema::Hs::ModuleName; };
template<> struct SCHEMA::predicate<261> { using type = facebook::glean::cpp::schema::Hs::ModuleDeclarations; };
template<> struct SCHEMA::predicate<262> { using type = facebook::glean::cpp::schema::Hs::Module; };
template<> struct SCHEMA::predicate<263> { using type = facebook::glean::cpp::schema::Hs::MethDecl; };
template<> struct SCHEMA::predicate<264> { using type = facebook::glean::cpp::schema::Hs::LitType; };
template<> struct SCHEMA::predicate<265> { using type = facebook::glean::cpp::schema::Hs::InstanceDecl; };
template<> struct SCHEMA::predicate<266> { using type = facebook::glean::cpp::schema::Hs::InstanceBindToDecl; };
template<> struct SCHEMA::predicate<267> { using type = facebook::glean::cpp::schema::Hs::InstanceBind; };
template<> struct SCHEMA::predicate<268> { using type = facebook::glean::cpp::schema::Hs::FileXRefs; };
template<> struct SCHEMA::predicate<269> { using type = facebook::glean::cpp::schema::Hs::DeclarationLocation; };
template<> struct SCHEMA::predicate<270> { using type = facebook::glean::cpp::schema::Hs::DeclarationOfName; };
template<> struct SCHEMA::predicate<271> { using type = facebook::glean::cpp::schema::Hs::DeclarationSpan; };
template<> struct SCHEMA::predicate<272> { using type = facebook::glean::cpp::schema::Hs::DataDecl; };
template<> struct SCHEMA::predicate<273> { using type = facebook::glean::cpp::schema::Hs::ConstrDecl; };
template<> struct SCHEMA::predicate<274> { using type = facebook::glean::cpp::schema::Hs::ClassDecl; };
template<> struct SCHEMA::predicate<275> { using type = facebook::glean::cpp::schema::Hs::Type; };
template<> struct SCHEMA::predicate<276> { using type = facebook::glean::cpp::schema::Hack::UserAttribute; };
template<> struct SCHEMA::predicate<277> { using type = facebook::glean::cpp::schema::Hack::TypedefDeclaration; };
template<> struct SCHEMA::predicate<278> { using type = facebook::glean::cpp::schema::Hack::TypeConstDefinition; };
template<> struct SCHEMA::predicate<279> { using type = facebook::glean::cpp::schema::Hack::Type; };
template<> struct SCHEMA::predicate<280> { using type = facebook::glean::cpp::schema::Hack::TraitDeclaration; };
template<> struct SCHEMA::predicate<281> { using type = facebook::glean::cpp::schema::Hack::StringLiteral; };
template<> struct SCHEMA::predicate<282> { using type = facebook::glean::cpp::schema::Hack::SearchTypedefByLowerCaseName; };
template<> struct SCHEMA::predicate<283> { using type = facebook::glean::cpp::schema::Hack::SearchTypeConstByLowerCaseName; };
template<> struct SCHEMA::predicate<284> { using type = facebook::glean::cpp::schema::Hack::SearchTraitByLowerCaseName; };
template<> struct SCHEMA::predicate<285> { using type = facebook::glean::cpp::schema::Hack::SearchPropertyByLowerCaseName; };
template<> struct SCHEMA::predicate<286> { using type = facebook::glean::cpp::schema::Hack::SearchNamespaceByLowerCaseName; };
template<> struct SCHEMA::predicate<287> { using type = facebook::glean::cpp::schema::Hack::SearchModuleByLowerCaseName; };
template<> struct SCHEMA::predicate<288> { using type = facebook::glean::cpp::schema::Hack::SearchMethodByLowerCaseName; };
template<> struct SCHEMA::predicate<289> { using type = facebook::glean::cpp::schema::Hack::SearchInterfaceByLowerCaseName; };
template<> struct SCHEMA::predicate<290> { using type = facebook::glean::cpp::schema::Hack::SearchGlobalConstByLowerCaseName; };
template<> struct SCHEMA::predicate<291> { using type = facebook::glean::cpp::schema::Hack::SearchFunctionByLowerCaseName; };
template<> struct SCHEMA::predicate<292> { using type = facebook::glean::cpp::schema::Hack::SearchEnumeratorByLowerCaseName; };
template<> struct SCHEMA::predicate<293> { using type = facebook::glean::cpp::schema::Hack::SearchEnumByLowerCaseName; };
template<> struct SCHEMA::predicate<294> { using type = facebook::glean::cpp::schema::Hack::SearchClassConstByLowerCaseName; };
template<> struct SCHEMA::predicate<295> { using type = facebook::glean::cpp::schema::Hack::SearchClassByLowerCaseName; };
template<> struct SCHEMA::predicate<296> { using type = facebook::glean::cpp::schema::Hack::QName; };
template<> struct SCHEMA::predicate<297> { using type = facebook::glean::cpp::schema::Hack::PropertyDefinition; };
template<> struct SCHEMA::predicate<298> { using type = facebook::glean::cpp::schema::Hack::Signature; };
template<> struct SCHEMA::predicate<299> { using type = facebook::glean::cpp::schema::Hack::NamespaceQName; };
template<> struct SCHEMA::predicate<300> { using type = facebook::glean::cpp::schema::Hack::NamespaceDeclaration; };
template<> struct SCHEMA::predicate<301> { using type = facebook::glean::cpp::schema::Hack::NameLowerCase; };
template<> struct SCHEMA::predicate<302> { using type = facebook::glean::cpp::schema::Hack::Name; };
template<> struct SCHEMA::predicate<303> { using type = facebook::glean::cpp::schema::Hack::ModuleDefinition; };
template<> struct SCHEMA::predicate<304> { using type = facebook::glean::cpp::schema::Hack::ModuleDeclaration; };
template<> struct SCHEMA::predicate<305> { using type = facebook::glean::cpp::schema::Hack::MethodOverrides; };
template<> struct SCHEMA::predicate<306> { using type = facebook::glean::cpp::schema::Hack::MethodOverridden; };
template<> struct SCHEMA::predicate<307> { using type = facebook::glean::cpp::schema::Hack::MethodOccurrence; };
template<> struct SCHEMA::predicate<308> { using type = facebook::glean::cpp::schema::Hack::InterfaceDeclaration; };
template<> struct SCHEMA::predicate<309> { using type = facebook::glean::cpp::schema::Hack::IndexerInputsHash; };
template<> struct SCHEMA::predicate<310> { using type = facebook::glean::cpp::schema::Hack::GlobalNamespaceAlias; };
template<> struct SCHEMA::predicate<311> { using type = facebook::glean::cpp::schema::Hack::GlobalConstDefinition; };
template<> struct SCHEMA::predicate<312> { using type = facebook::glean::cpp::schema::Hack::GlobalConstDeclaration; };
template<> struct SCHEMA::predicate<313> { using type = facebook::glean::cpp::schema::Hack::FunctionDeclaration; };
template<> struct SCHEMA::predicate<314> { using type = facebook::glean::cpp::schema::Hack::Hint; };
template<> struct SCHEMA::predicate<315> { using type = facebook::glean::cpp::schema::Hack::Enumerator; };
template<> struct SCHEMA::predicate<316> { using type = facebook::glean::cpp::schema::Hack::EnumDefinition; };
template<> struct SCHEMA::predicate<317> { using type = facebook::glean::cpp::schema::Hack::EnumDeclaration; };
template<> struct SCHEMA::predicate<318> { using type = facebook::glean::cpp::schema::Hack::Context_; };
template<> struct SCHEMA::predicate<319> { using type = facebook::glean::cpp::schema::Hack::ContainerDeclarationQName; };
template<> struct SCHEMA::predicate<320> { using type = facebook::glean::cpp::schema::Hack::ContainerParent; };
template<> struct SCHEMA::predicate<321> { using type = facebook::glean::cpp::schema::Hack::DeclarationComment; };
template<> struct SCHEMA::predicate<322> { using type = facebook::glean::cpp::schema::Hack::DeclarationLocation; };
template<> struct SCHEMA::predicate<323> { using type = facebook::glean::cpp::schema::Hack::DeclarationName; };
template<> struct SCHEMA::predicate<324> { using type = facebook::glean::cpp::schema::Hack::DeclarationNamespace; };
template<> struct SCHEMA::predicate<325> { using type = facebook::glean::cpp::schema::Hack::DeclarationSource; };
template<> struct SCHEMA::predicate<326> { using type = facebook::glean::cpp::schema::Hack::DeclarationSpan; };
template<> struct SCHEMA::predicate<327> { using type = facebook::glean::cpp::schema::Hack::DeclarationTarget; };
template<> struct SCHEMA::predicate<328> { using type = facebook::glean::cpp::schema::Hack::FileDeclarations; };
template<> struct SCHEMA::predicate<329> { using type = facebook::glean::cpp::schema::Hack::MemberCluster; };
template<> struct SCHEMA::predicate<330> { using type = facebook::glean::cpp::schema::Hack::ModuleChild; };
template<> struct SCHEMA::predicate<331> { using type = facebook::glean::cpp::schema::Hack::ModuleParent; };
template<> struct SCHEMA::predicate<332> { using type = facebook::glean::cpp::schema::Hack::NamespaceMember; };
template<> struct SCHEMA::predicate<333> { using type = facebook::glean::cpp::schema::Hack::SearchClassByName; };
template<> struct SCHEMA::predicate<334> { using type = facebook::glean::cpp::schema::Hack::SearchClassConstByName; };
template<> struct SCHEMA::predicate<335> { using type = facebook::glean::cpp::schema::Hack::SearchEnumByName; };
template<> struct SCHEMA::predicate<336> { using type = facebook::glean::cpp::schema::Hack::SearchEnumeratorByName; };
template<> struct SCHEMA::predicate<337> { using type = facebook::glean::cpp::schema::Hack::SearchFunctionByName; };
template<> struct SCHEMA::predicate<338> { using type = facebook::glean::cpp::schema::Hack::SearchGlobalConstByName; };
template<> struct SCHEMA::predicate<339> { using type = facebook::glean::cpp::schema::Hack::SearchInterfaceByName; };
template<> struct SCHEMA::predicate<340> { using type = facebook::glean::cpp::schema::Hack::SearchMethodByName; };
template<> struct SCHEMA::predicate<341> { using type = facebook::glean::cpp::schema::Hack::SearchModuleByName; };
template<> struct SCHEMA::predicate<342> { using type = facebook::glean::cpp::schema::Hack::SearchNamespaceByName; };
template<> struct SCHEMA::predicate<343> { using type = facebook::glean::cpp::schema::Hack::SearchPropertyByName; };
template<> struct SCHEMA::predicate<344> { using type = facebook::glean::cpp::schema::Hack::SearchTraitByName; };
template<> struct SCHEMA::predicate<345> { using type = facebook::glean::cpp::schema::Hack::SearchTypeConstByName; };
template<> struct SCHEMA::predicate<346> { using type = facebook::glean::cpp::schema::Hack::SearchTypedefByName; };
template<> struct SCHEMA::predicate<347> { using type = facebook::glean::cpp::schema::Hack::TargetUses; };
template<> struct SCHEMA::predicate<348> { using type = facebook::glean::cpp::schema::Hack::TargetUsesAbs; };
template<> struct SCHEMA::predicate<349> { using type = facebook::glean::cpp::schema::Hack::FileXRefs; };
template<> struct SCHEMA::predicate<350> { using type = facebook::glean::cpp::schema::Hack::TypeInfo; };
template<> struct SCHEMA::predicate<351> { using type = facebook::glean::cpp::schema::Search::Hack::SearchByName; };
template<> struct SCHEMA::predicate<352> { using type = facebook::glean::cpp::schema::Search::Hack::SearchFunctionInNamespace; };
template<> struct SCHEMA::predicate<353> { using type = facebook::glean::cpp::schema::Search::Hack::SearchGlobalConstInNamespace; };
template<> struct SCHEMA::predicate<354> { using type = facebook::glean::cpp::schema::Search::Hack::SearchInContainer; };
template<> struct SCHEMA::predicate<355> { using type = facebook::glean::cpp::schema::Search::Hack::SearchInContainerNoProperty; };
template<> struct SCHEMA::predicate<356> { using type = facebook::glean::cpp::schema::Search::Hack::SearchInContainerOrEnum; };
template<> struct SCHEMA::predicate<357> { using type = facebook::glean::cpp::schema::Search::Hack::SearchInContainerOrEnumNoProperty; };
template<> struct SCHEMA::predicate<358> { using type = facebook::glean::cpp::schema::Search::Hack::SearchInEnum; };
template<> struct SCHEMA::predicate<359> { using type = facebook::glean::cpp::schema::Search::Hack::SearchInNamespace; };
template<> struct SCHEMA::predicate<360> { using type = facebook::glean::cpp::schema::Search::Hack::SearchModule; };
template<> struct SCHEMA::predicate<361> { using type = facebook::glean::cpp::schema::Search::Hack::SearchNamespace; };
template<> struct SCHEMA::predicate<362> { using type = facebook::glean::cpp::schema::Search::Hack::SearchNamespacedDecl; };
template<> struct SCHEMA::predicate<363> { using type = facebook::glean::cpp::schema::Search::Hack::SearchPropertyInContainer; };
template<> struct SCHEMA::predicate<364> { using type = facebook::glean::cpp::schema::Search::Hack::SearchTypeInNamespace; };
template<> struct SCHEMA::predicate<365> { using type = facebook::glean::cpp::schema::Hack::InheritedMembers; };
template<> struct SCHEMA::predicate<366> { using type = facebook::glean::cpp::schema::Hack::MethodDeclaration; };
template<> struct SCHEMA::predicate<367> { using type = facebook::glean::cpp::schema::Hack::PropertyDeclaration; };
template<> struct SCHEMA::predicate<368> { using type = facebook::glean::cpp::schema::Hack::TypeConstDeclaration; };
template<> struct SCHEMA::predicate<369> { using type = facebook::glean::cpp::schema::Hack::ContainerChild; };
template<> struct SCHEMA::predicate<370> { using type = facebook::glean::cpp::schema::Hack::FunctionDefinition; };
template<> struct SCHEMA::predicate<371> { using type = facebook::glean::cpp::schema::Hack::InterfaceDefinition; };
template<> struct SCHEMA::predicate<372> { using type = facebook::glean::cpp::schema::Hack::MethodDefinition; };
template<> struct SCHEMA::predicate<373> { using type = facebook::glean::cpp::schema::Hack::TraitDefinition; };
template<> struct SCHEMA::predicate<374> { using type = facebook::glean::cpp::schema::Hack::TypedefDefinition; };
template<> struct SCHEMA::predicate<375> { using type = facebook::glean::cpp::schema::Hack::ClassDefinition; };
template<> struct SCHEMA::predicate<376> { using type = facebook::glean::cpp::schema::Hack::ClassDeclaration; };
template<> struct SCHEMA::predicate<377> { using type = facebook::glean::cpp::schema::Hack::ClassConstDefinition; };
template<> struct SCHEMA::predicate<378> { using type = facebook::glean::cpp::schema::Hack::ClassConstDeclaration; };
template<> struct SCHEMA::predicate<379> { using type = facebook::glean::cpp::schema::Hack::AttributeToDefinition; };
template<> struct SCHEMA::predicate<380> { using type = facebook::glean::cpp::schema::Hack::AttributeToDeclaration; };
template<> struct SCHEMA::predicate<381> { using type = facebook::glean::cpp::schema::Hack::AttributeHasParameter; };
template<> struct SCHEMA::predicate<382> { using type = facebook::glean::cpp::schema::Hack::FileCall; };
template<> struct SCHEMA::predicate<383> { using type = facebook::glean::cpp::schema::Graphql::VariableDef; };
template<> struct SCHEMA::predicate<384> { using type = facebook::glean::cpp::schema::Graphql::Value; };
template<> struct SCHEMA::predicate<385> { using type = facebook::glean::cpp::schema::Graphql::UnionTypeDef; };
template<> struct SCHEMA::predicate<386> { using type = facebook::glean::cpp::schema::Graphql::ScalarTypeDef; };
template<> struct SCHEMA::predicate<387> { using type = facebook::glean::cpp::schema::Graphql::Operation; };
template<> struct SCHEMA::predicate<388> { using type = facebook::glean::cpp::schema::Graphql::ObjectTypeDef; };
template<> struct SCHEMA::predicate<389> { using type = facebook::glean::cpp::schema::Graphql::NameLowerCase; };
template<> struct SCHEMA::predicate<390> { using type = facebook::glean::cpp::schema::Graphql::InterfaceTypeDef; };
template<> struct SCHEMA::predicate<391> { using type = facebook::glean::cpp::schema::Graphql::InputValueDef; };
template<> struct SCHEMA::predicate<392> { using type = facebook::glean::cpp::schema::Graphql::InputObjectTypeDef; };
template<> struct SCHEMA::predicate<393> { using type = facebook::glean::cpp::schema::Graphql::InlineFragment; };
template<> struct SCHEMA::predicate<394> { using type = facebook::glean::cpp::schema::Graphql::FragmentSpread; };
template<> struct SCHEMA::predicate<395> { using type = facebook::glean::cpp::schema::Graphql::Fragment; };
template<> struct SCHEMA::predicate<396> { using type = facebook::glean::cpp::schema::Graphql::FieldDef; };
template<> struct SCHEMA::predicate<397> { using type = facebook::glean::cpp::schema::Graphql::Field; };
template<> struct SCHEMA::predicate<398> { using type = facebook::glean::cpp::schema::Graphql::EnumTypeDef; };
template<> struct SCHEMA::predicate<399> { using type = facebook::glean::cpp::schema::Graphql::DirectiveDef; };
template<> struct SCHEMA::predicate<400> { using type = facebook::glean::cpp::schema::Graphql::Directive; };
template<> struct SCHEMA::predicate<401> { using type = facebook::glean::cpp::schema::Graphql::DeclarationLocation; };
template<> struct SCHEMA::predicate<402> { using type = facebook::glean::cpp::schema::Graphql::DeclarationName; };
template<> struct SCHEMA::predicate<403> { using type = facebook::glean::cpp::schema::Graphql::DeclarationUses; };
template<> struct SCHEMA::predicate<404> { using type = facebook::glean::cpp::schema::Graphql::FileDeclarations; };
template<> struct SCHEMA::predicate<405> { using type = facebook::glean::cpp::schema::Graphql::SearchByName; };
template<> struct SCHEMA::predicate<406> { using type = facebook::glean::cpp::schema::Graphql::FileXRefs; };
template<> struct SCHEMA::predicate<407> { using type = facebook::glean::cpp::schema::Graphql::DeclHasName; };
template<> struct SCHEMA::predicate<408> { using type = facebook::glean::cpp::schema::Graphql::BelongToConfig; };
template<> struct SCHEMA::predicate<409> { using type = facebook::glean::cpp::schema::Graphql::Argument; };
template<> struct SCHEMA::predicate<410> { using type = facebook::glean::cpp::schema::Glean::Test::nothingTest; };
template<> struct SCHEMA::predicate<411> { using type = facebook::glean::cpp::schema::Glean::Test::ViaStringPair; };
template<> struct SCHEMA::predicate<412> { using type = facebook::glean::cpp::schema::Glean::Test::Unbound2; };
template<> struct SCHEMA::predicate<413> { using type = facebook::glean::cpp::schema::Glean::Test::Unbound; };
template<> struct SCHEMA::predicate<414> { using type = facebook::glean::cpp::schema::Glean::Test::TreeToTree; };
template<> struct SCHEMA::predicate<415> { using type = facebook::glean::cpp::schema::Glean::Test::Tree; };
template<> struct SCHEMA::predicate<416> { using type = facebook::glean::cpp::schema::Glean::Test::StringPairBox; };
template<> struct SCHEMA::predicate<417> { using type = facebook::glean::cpp::schema::Glean::Test::StringPair; };
template<> struct SCHEMA::predicate<418> { using type = facebook::glean::cpp::schema::Glean::Test::StoredRevStringPairWithRev; };
template<> struct SCHEMA::predicate<419> { using type = facebook::glean::cpp::schema::Glean::Test::StoredRevStringPairWithA; };
template<> struct SCHEMA::predicate<420> { using type = facebook::glean::cpp::schema::Glean::Test::StoredRevStringPairSum; };
template<> struct SCHEMA::predicate<421> { using type = facebook::glean::cpp::schema::Glean::Test::StoredRevStringPair; };
template<> struct SCHEMA::predicate<422> { using type = facebook::glean::cpp::schema::Glean::Test::StoredDualStringPair; };
template<> struct SCHEMA::predicate<423> { using type = facebook::glean::cpp::schema::Glean::Test::SkipRevEdge; };
template<> struct SCHEMA::predicate<424> { using type = facebook::glean::cpp::schema::Glean::Test::SameString; };
template<> struct SCHEMA::predicate<425> { using type = facebook::glean::cpp::schema::Glean::Test::RevStringPairs; };
template<> struct SCHEMA::predicate<426> { using type = facebook::glean::cpp::schema::Glean::Test::RevStringPairRec; };
template<> struct SCHEMA::predicate<427> { using type = facebook::glean::cpp::schema::Glean::Test::RevStringPair; };
template<> struct SCHEMA::predicate<428> { using type = facebook::glean::cpp::schema::Glean::Test::RevRevStringPair; };
template<> struct SCHEMA::predicate<429> { using type = facebook::glean::cpp::schema::Glean::Test::RevEdge; };
template<> struct SCHEMA::predicate<430> { using type = facebook::glean::cpp::schema::Glean::Test::ReflStringPair; };
template<> struct SCHEMA::predicate<431> { using type = facebook::glean::cpp::schema::Glean::Test::RefRef; };
template<> struct SCHEMA::predicate<432> { using type = facebook::glean::cpp::schema::Glean::Test::Ref; };
template<> struct SCHEMA::predicate<433> { using type = facebook::glean::cpp::schema::Glean::Test::Qux; };
template<> struct SCHEMA::predicate<434> { using type = facebook::glean::cpp::schema::Glean::Test::Predicate_0; };
template<> struct SCHEMA::predicate<435> { using type = facebook::glean::cpp::schema::Glean::Test::NodePair; };
template<> struct SCHEMA::predicate<436> { using type = facebook::glean::cpp::schema::Glean::Test::Node; };
template<> struct SCHEMA::predicate<437> { using type = facebook::glean::cpp::schema::Glean::Test::Name; };
template<> struct SCHEMA::predicate<438> { using type = facebook::glean::cpp::schema::Glean::Test::MatchOneAlt; };
template<> struct SCHEMA::predicate<439> { using type = facebook::glean::cpp::schema::Glean::Test::LeftOr2; };
template<> struct SCHEMA::predicate<440> { using type = facebook::glean::cpp::schema::Glean::Test::LeftOr; };
template<> struct SCHEMA::predicate<441> { using type = facebook::glean::cpp::schema::Glean::Test::KeyValue; };
template<> struct SCHEMA::predicate<442> { using type = facebook::glean::cpp::schema::Glean::Test::IsThree; };
template<> struct SCHEMA::predicate<443> { using type = facebook::glean::cpp::schema::Glean::Test::IsParent; };
template<> struct SCHEMA::predicate<444> { using type = facebook::glean::cpp::schema::Glean::Test::IsGlean; };
template<> struct SCHEMA::predicate<445> { using type = facebook::glean::cpp::schema::Glean::Test::FooToFoo; };
template<> struct SCHEMA::predicate<446> { using type = facebook::glean::cpp::schema::Glean::Test::Foo; };
template<> struct SCHEMA::predicate<447> { using type = facebook::glean::cpp::schema::Glean::Test::Expr; };
template<> struct SCHEMA::predicate<448> { using type = facebook::glean::cpp::schema::Glean::Test::EmptyStoredStringPair; };
template<> struct SCHEMA::predicate<449> { using type = facebook::glean::cpp::schema::Glean::Test::EmptyPred; };
template<> struct SCHEMA::predicate<450> { using type = facebook::glean::cpp::schema::Glean::Test::EdgeWrapper; };
template<> struct SCHEMA::predicate<451> { using type = facebook::glean::cpp::schema::Glean::Test::EdgeFromNotA; };
template<> struct SCHEMA::predicate<452> { using type = facebook::glean::cpp::schema::Glean::Test::Edge; };
template<> struct SCHEMA::predicate<453> { using type = facebook::glean::cpp::schema::Glean::Test::DualStringPair; };
template<> struct SCHEMA::predicate<454> { using type = facebook::glean::cpp::schema::Glean::Test::DerivedKeyValue2; };
template<> struct SCHEMA::predicate<455> { using type = facebook::glean::cpp::schema::Glean::Test::DerivedKeyValue; };
template<> struct SCHEMA::predicate<456> { using type = facebook::glean::cpp::schema::Glean::Test::Bar; };
template<> struct SCHEMA::predicate<457> { using type = facebook::glean::cpp::schema::Glean::Test::Predicate_; };
template<> struct SCHEMA::predicate<458> { using type = facebook::glean::cpp::schema::Gencode::GenCodeSignature; };
template<> struct SCHEMA::predicate<459> { using type = facebook::glean::cpp::schema::Gencode::GenCodeCommand; };
template<> struct SCHEMA::predicate<460> { using type = facebook::glean::cpp::schema::Gencode::GenCodeClass; };
template<> struct SCHEMA::predicate<461> { using type = facebook::glean::cpp::schema::Gencode::GenCodeBySource; };
template<> struct SCHEMA::predicate<462> { using type = facebook::glean::cpp::schema::Gencode::GenCode; };
template<> struct SCHEMA::predicate<463> { using type = facebook::glean::cpp::schema::Flow::TypeImportDeclaration; };
template<> struct SCHEMA::predicate<464> { using type = facebook::glean::cpp::schema::Flow::TypeExport; };
template<> struct SCHEMA::predicate<465> { using type = facebook::glean::cpp::schema::Flow::TypeDeclarationReference; };
template<> struct SCHEMA::predicate<466> { using type = facebook::glean::cpp::schema::Flow::TypeDeclarationInfo; };
template<> struct SCHEMA::predicate<467> { using type = facebook::glean::cpp::schema::Flow::TypeDeclaration; };
template<> struct SCHEMA::predicate<468> { using type = facebook::glean::cpp::schema::Flow::Type; };
template<> struct SCHEMA::predicate<469> { using type = facebook::glean::cpp::schema::Flow::StringToFileModule; };
template<> struct SCHEMA::predicate<470> { using type = facebook::glean::cpp::schema::Flow::SourceOfTypeExport; };
template<> struct SCHEMA::predicate<471> { using type = facebook::glean::cpp::schema::Flow::SourceOfExport; };
template<> struct SCHEMA::predicate<472> { using type = facebook::glean::cpp::schema::Search::Flow::FlowSearchByNameNonImport; };
template<> struct SCHEMA::predicate<473> { using type = facebook::glean::cpp::schema::Flow::SearchTypeDeclarationByName; };
template<> struct SCHEMA::predicate<474> { using type = facebook::glean::cpp::schema::Flow::SearchTypeDeclarationByLowerCaseName; };
template<> struct SCHEMA::predicate<475> { using type = facebook::glean::cpp::schema::Flow::SearchTypeByModuleExport; };
template<> struct SCHEMA::predicate<476> { using type = facebook::glean::cpp::schema::Flow::SearchModuleByLowerCaseName; };
template<> struct SCHEMA::predicate<477> { using type = facebook::glean::cpp::schema::Flow::SearchMemberDeclarationByName; };
template<> struct SCHEMA::predicate<478> { using type = facebook::glean::cpp::schema::Flow::SearchMemberDeclarationByLowerCaseName; };
template<> struct SCHEMA::predicate<479> { using type = facebook::glean::cpp::schema::Flow::SearchDeclarationByName; };
template<> struct SCHEMA::predicate<480> { using type = facebook::glean::cpp::schema::Flow::SearchDeclarationByLowerCaseName; };
template<> struct SCHEMA::predicate<481> { using type = facebook::glean::cpp::schema::Flow::SearchByNameModule; };
template<> struct SCHEMA::predicate<482> { using type = facebook::glean::cpp::schema::Flow::SearchByName; };
template<> struct SCHEMA::predicate<483> { using type = facebook::glean::cpp::schema::Flow::SearchByModuleName; };
template<> struct SCHEMA::predicate<484> { using type = facebook::glean::cpp::schema::Flow::SearchByModule; };
template<> struct SCHEMA::predicate<485> { using type = facebook::glean::cpp::schema::Flow::SearchByFileModule; };
template<> struct SCHEMA::predicate<486> { using type = facebook::glean::cpp::schema::Flow::Range; };
template<> struct SCHEMA::predicate<487> { using type = facebook::glean::cpp::schema::Flow::Name; };
template<> struct SCHEMA::predicate<488> { using type = facebook::glean::cpp::schema::Flow::ModuleTypeExport; };
template<> struct SCHEMA::predicate<489> { using type = facebook::glean::cpp::schema::Flow::ModuleNameLowerCase; };
template<> struct SCHEMA::predicate<490> { using type = facebook::glean::cpp::schema::Flow::ModuleLocationByFile; };
template<> struct SCHEMA::predicate<491> { using type = facebook::glean::cpp::schema::Flow::ModuleLocation; };
template<> struct SCHEMA::predicate<492> { using type = facebook::glean::cpp::schema::Flow::ModuleExport; };
template<> struct SCHEMA::predicate<493> { using type = facebook::glean::cpp::schema::Flow::ModuleDoc; };
template<> struct SCHEMA::predicate<494> { using type = facebook::glean::cpp::schema::Flow::ModuleContains; };
template<> struct SCHEMA::predicate<495> { using type = facebook::glean::cpp::schema::Flow::ModuleComments; };
template<> struct SCHEMA::predicate<496> { using type = facebook::glean::cpp::schema::Flow::Module; };
template<> struct SCHEMA::predicate<497> { using type = facebook::glean::cpp::schema::Flow::MemberDeclarationReference; };
template<> struct SCHEMA::predicate<498> { using type = facebook::glean::cpp::schema::Flow::MemberDeclarationInfo; };
template<> struct SCHEMA::predicate<499> { using type = facebook::glean::cpp::schema::Flow::MemberDeclaration; };
template<> struct SCHEMA::predicate<500> { using type = facebook::glean::cpp::schema::Flow::LocalDeclarationReference; };
template<> struct SCHEMA::predicate<501> { using type = facebook::glean::cpp::schema::Flow::ImportDeclaration; };
template<> struct SCHEMA::predicate<502> { using type = facebook::glean::cpp::schema::Flow::FlowXRefDeclInfo; };
template<> struct SCHEMA::predicate<503> { using type = facebook::glean::cpp::schema::Flow::FlowTypeImportXRef; };
template<> struct SCHEMA::predicate<504> { using type = facebook::glean::cpp::schema::Flow::FlowTypeExportLocation; };
template<> struct SCHEMA::predicate<505> { using type = facebook::glean::cpp::schema::Flow::FlowTypeEntityImportUses; };
template<> struct SCHEMA::predicate<506> { using type = facebook::glean::cpp::schema::Flow::FlowSameModule; };
template<> struct SCHEMA::predicate<507> { using type = facebook::glean::cpp::schema::Flow::FlowModuleNamespaceXRef; };
template<> struct SCHEMA::predicate<508> { using type = facebook::glean::cpp::schema::Flow::FlowImportXRef; };
template<> struct SCHEMA::predicate<509> { using type = facebook::glean::cpp::schema::Flow::FlowExportLocation; };
template<> struct SCHEMA::predicate<510> { using type = facebook::glean::cpp::schema::Flow::FlowEntityUsesAll; };
template<> struct SCHEMA::predicate<511> { using type = facebook::glean::cpp::schema::Flow::FlowEntityImportUses; };
template<> struct SCHEMA::predicate<512> { using type = facebook::glean::cpp::schema::Flow::FlowCompatibleExport; };
template<> struct SCHEMA::predicate<513> { using type = facebook::glean::cpp::schema::Flow::FileXRef; };
template<> struct SCHEMA::predicate<514> { using type = facebook::glean::cpp::schema::Flow::FileOfStringModule; };
template<> struct SCHEMA::predicate<515> { using type = facebook::glean::cpp::schema::Flow::FileDeclaration; };
template<> struct SCHEMA::predicate<516> { using type = facebook::glean::cpp::schema::Flow::Export; };
template<> struct SCHEMA::predicate<517> { using type = facebook::glean::cpp::schema::Flow::Documentation; };
template<> struct SCHEMA::predicate<518> { using type = facebook::glean::cpp::schema::Flow::DeclarationUses; };
template<> struct SCHEMA::predicate<519> { using type = facebook::glean::cpp::schema::Flow::DeclarationSignature; };
template<> struct SCHEMA::predicate<520> { using type = facebook::glean::cpp::schema::Flow::DeclarationNameSpan; };
template<> struct SCHEMA::predicate<521> { using type = facebook::glean::cpp::schema::Flow::DeclarationLocation; };
template<> struct SCHEMA::predicate<522> { using type = facebook::glean::cpp::schema::Flow::DeclarationInfo; };
template<> struct SCHEMA::predicate<523> { using type = facebook::glean::cpp::schema::Flow::Declaration; };
template<> struct SCHEMA::predicate<524> { using type = facebook::glean::cpp::schema::Fbthrift::UnionVal; };
template<> struct SCHEMA::predicate<525> { using type = facebook::glean::cpp::schema::Fbthrift::TypeDefType; };
template<> struct SCHEMA::predicate<526> { using type = facebook::glean::cpp::schema::Fbthrift::StructuredAnnotation; };
template<> struct SCHEMA::predicate<527> { using type = facebook::glean::cpp::schema::Fbthrift::StructVal; };
template<> struct SCHEMA::predicate<528> { using type = facebook::glean::cpp::schema::Fbthrift::ServiceParent; };
template<> struct SCHEMA::predicate<529> { using type = facebook::glean::cpp::schema::Fbthrift::ServiceName; };
template<> struct SCHEMA::predicate<530> { using type = facebook::glean::cpp::schema::Fbthrift::ServiceInteractionFunctions; };
template<> struct SCHEMA::predicate<531> { using type = facebook::glean::cpp::schema::Fbthrift::ServiceDefinition; };
template<> struct SCHEMA::predicate<532> { using type = facebook::glean::cpp::schema::Fbthrift::ServiceChild; };
template<> struct SCHEMA::predicate<533> { using type = facebook::glean::cpp::schema::Fbthrift::SearchByName; };
template<> struct SCHEMA::predicate<534> { using type = facebook::glean::cpp::schema::Fbthrift::QualName; };
template<> struct SCHEMA::predicate<535> { using type = facebook::glean::cpp::schema::Fbthrift::PackageName; };
template<> struct SCHEMA::predicate<536> { using type = facebook::glean::cpp::schema::Fbthrift::Package; };
template<> struct SCHEMA::predicate<537> { using type = facebook::glean::cpp::schema::Fbthrift::NamespaceValue; };
template<> struct SCHEMA::predicate<538> { using type = facebook::glean::cpp::schema::Fbthrift::NamespaceName; };
template<> struct SCHEMA::predicate<539> { using type = facebook::glean::cpp::schema::Fbthrift::Namespace; };
template<> struct SCHEMA::predicate<540> { using type = facebook::glean::cpp::schema::Fbthrift::NamedDecl; };
template<> struct SCHEMA::predicate<541> { using type = facebook::glean::cpp::schema::Fbthrift::NameLowerCase; };
template<> struct SCHEMA::predicate<542> { using type = facebook::glean::cpp::schema::Fbthrift::InteractionName; };
template<> struct SCHEMA::predicate<543> { using type = facebook::glean::cpp::schema::Fbthrift::InteractionDefinition; };
template<> struct SCHEMA::predicate<544> { using type = facebook::glean::cpp::schema::Fbthrift::Identifier; };
template<> struct SCHEMA::predicate<545> { using type = facebook::glean::cpp::schema::Fbthrift::FunctionName; };
template<> struct SCHEMA::predicate<546> { using type = facebook::glean::cpp::schema::Fbthrift::Literal; };
template<> struct SCHEMA::predicate<547> { using type = facebook::glean::cpp::schema::Fbthrift::FileXRefs; };
template<> struct SCHEMA::predicate<548> { using type = facebook::glean::cpp::schema::Fbthrift::File; };
template<> struct SCHEMA::predicate<549> { using type = facebook::glean::cpp::schema::Fbthrift::StructType; };
template<> struct SCHEMA::predicate<550> { using type = facebook::glean::cpp::schema::Fbthrift::UnionType; };
template<> struct SCHEMA::predicate<551> { using type = facebook::glean::cpp::schema::Fbthrift::FieldDecl; };
template<> struct SCHEMA::predicate<552> { using type = facebook::glean::cpp::schema::Fbthrift::ExceptionVal; };
template<> struct SCHEMA::predicate<553> { using type = facebook::glean::cpp::schema::Fbthrift::ExceptionType; };
template<> struct SCHEMA::predicate<554> { using type = facebook::glean::cpp::schema::Fbthrift::TypeDefException; };
template<> struct SCHEMA::predicate<555> { using type = facebook::glean::cpp::schema::Fbthrift::ExceptionName; };
template<> struct SCHEMA::predicate<556> { using type = facebook::glean::cpp::schema::Fbthrift::EnumerationType; };
template<> struct SCHEMA::predicate<557> { using type = facebook::glean::cpp::schema::Fbthrift::EnumValueDef; };
template<> struct SCHEMA::predicate<558> { using type = facebook::glean::cpp::schema::Fbthrift::EnumValue; };
template<> struct SCHEMA::predicate<559> { using type = facebook::glean::cpp::schema::Fbthrift::EnumVal; };
template<> struct SCHEMA::predicate<560> { using type = facebook::glean::cpp::schema::Fbthrift::DeclarationComment; };
template<> struct SCHEMA::predicate<561> { using type = facebook::glean::cpp::schema::Fbthrift::DeclarationFile; };
template<> struct SCHEMA::predicate<562> { using type = facebook::glean::cpp::schema::Fbthrift::DeclarationMember; };
template<> struct SCHEMA::predicate<563> { using type = facebook::glean::cpp::schema::Fbthrift::DeclarationName; };
template<> struct SCHEMA::predicate<564> { using type = facebook::glean::cpp::schema::Fbthrift::DeclarationNameSpan; };
template<> struct SCHEMA::predicate<565> { using type = facebook::glean::cpp::schema::Fbthrift::DeclarationUses; };
template<> struct SCHEMA::predicate<566> { using type = facebook::glean::cpp::schema::Fbthrift::FileDeclaration; };
template<> struct SCHEMA::predicate<567> { using type = facebook::glean::cpp::schema::Fbthrift::FunctionDeclarationName; };
template<> struct SCHEMA::predicate<568> { using type = facebook::glean::cpp::schema::Hack::HackToThrift; };
template<> struct SCHEMA::predicate<569> { using type = facebook::glean::cpp::schema::Hack::ThriftToHack; };
template<> struct SCHEMA::predicate<570> { using type = facebook::glean::cpp::schema::Fbthrift::TypeSpecification; };
template<> struct SCHEMA::predicate<571> { using type = facebook::glean::cpp::schema::Fbthrift::ConstantDefinition; };
template<> struct SCHEMA::predicate<572> { using type = facebook::glean::cpp::schema::Fbthrift::Constant; };
template<> struct SCHEMA::predicate<573> { using type = facebook::glean::cpp::schema::Erlang::NameLowerCase; };
template<> struct SCHEMA::predicate<574> { using type = facebook::glean::cpp::schema::Erlang::FunctionDeclaration; };
template<> struct SCHEMA::predicate<575> { using type = facebook::glean::cpp::schema::Erlang::XRefsViaFqnByFile; };
template<> struct SCHEMA::predicate<576> { using type = facebook::glean::cpp::schema::Erlang::DeclarationComment; };
template<> struct SCHEMA::predicate<577> { using type = facebook::glean::cpp::schema::Erlang::DeclarationLocation; };
template<> struct SCHEMA::predicate<578> { using type = facebook::glean::cpp::schema::Erlang::DeclarationReference; };
template<> struct SCHEMA::predicate<579> { using type = facebook::glean::cpp::schema::Erlang::DeclarationToFqn; };
template<> struct SCHEMA::predicate<580> { using type = facebook::glean::cpp::schema::Erlang::DeclarationUses; };
template<> struct SCHEMA::predicate<581> { using type = facebook::glean::cpp::schema::Erlang::DeclarationWithFqn; };
template<> struct SCHEMA::predicate<582> { using type = facebook::glean::cpp::schema::Erlang::DeclarationsByFile; };
template<> struct SCHEMA::predicate<583> { using type = facebook::glean::cpp::schema::Erlang::SearchByName; };
template<> struct SCHEMA::predicate<584> { using type = facebook::glean::cpp::schema::Dyn::ObserverIdentifier; };
template<> struct SCHEMA::predicate<585> { using type = facebook::glean::cpp::schema::Dyn::Environment; };
template<> struct SCHEMA::predicate<586> { using type = facebook::glean::cpp::schema::Dyn::EntityDynamicReference; };
template<> struct SCHEMA::predicate<587> { using type = facebook::glean::cpp::schema::Digest::FileDigest; };
template<> struct SCHEMA::predicate<588> { using type = facebook::glean::cpp::schema::Glass::FileInfo; };
template<> struct SCHEMA::predicate<589> { using type = facebook::glean::cpp::schema::Dataswarm::TableDeclaration; };
template<> struct SCHEMA::predicate<590> { using type = facebook::glean::cpp::schema::Dataswarm::TableColumnDeclaration; };
template<> struct SCHEMA::predicate<591> { using type = facebook::glean::cpp::schema::Dataswarm::SubqueryDeclaration; };
template<> struct SCHEMA::predicate<592> { using type = facebook::glean::cpp::schema::Dataswarm::SubqueryColumnDeclaration; };
template<> struct SCHEMA::predicate<593> { using type = facebook::glean::cpp::schema::Dataswarm::MacroDeclaration; };
template<> struct SCHEMA::predicate<594> { using type = facebook::glean::cpp::schema::Dataswarm::DeclarationLocation; };
template<> struct SCHEMA::predicate<595> { using type = facebook::glean::cpp::schema::Dataswarm::DeclarationName; };
template<> struct SCHEMA::predicate<596> { using type = facebook::glean::cpp::schema::Dataswarm::XRefsByFile; };
template<> struct SCHEMA::predicate<597> { using type = facebook::glean::cpp::schema::Cxx1::VariableLowerCase; };
template<> struct SCHEMA::predicate<598> { using type = facebook::glean::cpp::schema::Cxx1::UsingDirective; };
template<> struct SCHEMA::predicate<599> { using type = facebook::glean::cpp::schema::Cxx1::UsingDeclaration; };
template<> struct SCHEMA::predicate<600> { using type = facebook::glean::cpp::schema::Cxx1::TypeAliasLowerCase; };
template<> struct SCHEMA::predicate<601> { using type = facebook::glean::cpp::schema::Cxx1::TypeAliasDeclaration; };
template<> struct SCHEMA::predicate<602> { using type = facebook::glean::cpp::schema::Cxx1::Type; };
template<> struct SCHEMA::predicate<603> { using type = facebook::glean::cpp::schema::Cxx1::TranslationUnitXRefs; };
template<> struct SCHEMA::predicate<604> { using type = facebook::glean::cpp::schema::Cxx1::TranslationUnitTrace; };
template<> struct SCHEMA::predicate<605> { using type = facebook::glean::cpp::schema::Cxx1::TranslationUnitIncludeTree; };
template<> struct SCHEMA::predicate<606> { using type = facebook::glean::cpp::schema::Cxx1::Trace; };
template<> struct SCHEMA::predicate<607> { using type = facebook::glean::cpp::schema::Cxx1::RecordUnionLowerCase; };
template<> struct SCHEMA::predicate<608> { using type = facebook::glean::cpp::schema::Cxx1::RecordStructLowerCase; };
template<> struct SCHEMA::predicate<609> { using type = facebook::glean::cpp::schema::Cxx1::RecordDerived; };
template<> struct SCHEMA::predicate<610> { using type = facebook::glean::cpp::schema::Cxx1::RecordClassLowerCase; };
template<> struct SCHEMA::predicate<611> { using type = facebook::glean::cpp::schema::Cxx1::Signature; };
template<> struct SCHEMA::predicate<612> { using type = facebook::glean::cpp::schema::Cxx1::PPDefineLocation; };
template<> struct SCHEMA::predicate<613> { using type = facebook::glean::cpp::schema::Cxx1::ObjcSelector; };
template<> struct SCHEMA::predicate<614> { using type = facebook::glean::cpp::schema::Cxx1::ObjcPropertyImplementation; };
template<> struct SCHEMA::predicate<615> { using type = facebook::glean::cpp::schema::Cxx1::ObjcPropertyIVar; };
template<> struct SCHEMA::predicate<616> { using type = facebook::glean::cpp::schema::Cxx1::ObjcMethodDefinition; };
template<> struct SCHEMA::predicate<617> { using type = facebook::glean::cpp::schema::Cxx1::ObjcMethodDeclarationName; };
template<> struct SCHEMA::predicate<618> { using type = facebook::glean::cpp::schema::Cxx1::ObjcInterfaceToImplementation; };
template<> struct SCHEMA::predicate<619> { using type = facebook::glean::cpp::schema::Cxx1::ObjcImplements; };
template<> struct SCHEMA::predicate<620> { using type = facebook::glean::cpp::schema::Cxx1::ObjcContainerInterfaceLowerCase; };
template<> struct SCHEMA::predicate<621> { using type = facebook::glean::cpp::schema::Cxx1::ObjcContainerInheritance; };
template<> struct SCHEMA::predicate<622> { using type = facebook::glean::cpp::schema::Cxx1::ObjcContainerDefinition; };
template<> struct SCHEMA::predicate<623> { using type = facebook::glean::cpp::schema::Cxx1::ObjcContainerDeclarationInterface; };
template<> struct SCHEMA::predicate<624> { using type = facebook::glean::cpp::schema::Cxx1::ObjcContainerBase; };
template<> struct SCHEMA::predicate<625> { using type = facebook::glean::cpp::schema::Cxx1::ObjcContainerDeclaration; };
template<> struct SCHEMA::predicate<626> { using type = facebook::glean::cpp::schema::Cxx1::ObjcMethodDeclaration; };
template<> struct SCHEMA::predicate<627> { using type = facebook::glean::cpp::schema::Cxx1::ObjcPropertyDeclaration; };
template<> struct SCHEMA::predicate<628> { using type = facebook::glean::cpp::schema::Cxx1::ObjContainerIdName; };
template<> struct SCHEMA::predicate<629> { using type = facebook::glean::cpp::schema::Cxx1::NamespaceQName; };
template<> struct SCHEMA::predicate<630> { using type = facebook::glean::cpp::schema::Cxx1::NamespaceLowerCase; };
template<> struct SCHEMA::predicate<631> { using type = facebook::glean::cpp::schema::Cxx1::NamespaceDefinition; };
template<> struct SCHEMA::predicate<632> { using type = facebook::glean::cpp::schema::Cxx1::NamespaceDeclarationName; };
template<> struct SCHEMA::predicate<633> { using type = facebook::glean::cpp::schema::Cxx1::NamespaceDeclarationByName; };
template<> struct SCHEMA::predicate<634> { using type = facebook::glean::cpp::schema::Cxx1::NamespaceDeclaration; };
template<> struct SCHEMA::predicate<635> { using type = facebook::glean::cpp::schema::Cxx1::NamespaceAliasDeclaration; };
template<> struct SCHEMA::predicate<636> { using type = facebook::glean::cpp::schema::Cxx1::Name; };
template<> struct SCHEMA::predicate<637> { using type = facebook::glean::cpp::schema::Cxx1::MethodOverrides; };
template<> struct SCHEMA::predicate<638> { using type = facebook::glean::cpp::schema::Cxx1::MethodOverridden; };
template<> struct SCHEMA::predicate<639> { using type = facebook::glean::cpp::schema::Cxx1::IncludeTreeTranslationUnit; };
template<> struct SCHEMA::predicate<640> { using type = facebook::glean::cpp::schema::Cxx1::IncludeTreeParent; };
template<> struct SCHEMA::predicate<641> { using type = facebook::glean::cpp::schema::Cxx1::IncludeTree; };
template<> struct SCHEMA::predicate<642> { using type = facebook::glean::cpp::schema::Cxx1::PPTrace; };
template<> struct SCHEMA::predicate<643> { using type = facebook::glean::cpp::schema::Cxx1::FunctionLowerCase; };
template<> struct SCHEMA::predicate<644> { using type = facebook::glean::cpp::schema::Cxx1::FunctionDefinition; };
template<> struct SCHEMA::predicate<645> { using type = facebook::glean::cpp::schema::Cxx1::FunctionDeclarationNameString; };
template<> struct SCHEMA::predicate<646> { using type = facebook::glean::cpp::schema::Cxx1::FunctionDeclarationName; };
template<> struct SCHEMA::predicate<647> { using type = facebook::glean::cpp::schema::Cxx1::FunctionDeclaration; };
template<> struct SCHEMA::predicate<648> { using type = facebook::glean::cpp::schema::Cxx1::FunctionDeclAttribute; };
template<> struct SCHEMA::predicate<649> { using type = facebook::glean::cpp::schema::Cxx1::FunctionAttribute; };
template<> struct SCHEMA::predicate<650> { using type = facebook::glean::cpp::schema::Cxx1::FileXRefs; };
template<> struct SCHEMA::predicate<651> { using type = facebook::glean::cpp::schema::Cxx1::FilePPUseXRefs; };
template<> struct SCHEMA::predicate<652> { using type = facebook::glean::cpp::schema::Cxx1::FilePPUseTraceXRefs; };
template<> struct SCHEMA::predicate<653> { using type = facebook::glean::cpp::schema::Cxx1::FilePPTraceXRefs; };
template<> struct SCHEMA::predicate<654> { using type = facebook::glean::cpp::schema::Cxx1::VariableDeclaration; };
template<> struct SCHEMA::predicate<655> { using type = facebook::glean::cpp::schema::Cxx1::EnumeratorLowerCase; };
template<> struct SCHEMA::predicate<656> { using type = facebook::glean::cpp::schema::Cxx1::EnumeratorInEnum; };
template<> struct SCHEMA::predicate<657> { using type = facebook::glean::cpp::schema::Cxx1::EnumeratorByName; };
template<> struct SCHEMA::predicate<658> { using type = facebook::glean::cpp::schema::Cxx1::Enumerator; };
template<> struct SCHEMA::predicate<659> { using type = facebook::glean::cpp::schema::Cxx1::EnumLowerCase; };
template<> struct SCHEMA::predicate<660> { using type = facebook::glean::cpp::schema::Cxx1::EnumDefinition; };
template<> struct SCHEMA::predicate<661> { using type = facebook::glean::cpp::schema::Cxx1::EnumDeclaration; };
template<> struct SCHEMA::predicate<662> { using type = facebook::glean::cpp::schema::Cxx1::DefnInRecord; };
template<> struct SCHEMA::predicate<663> { using type = facebook::glean::cpp::schema::Cxx1::DeclarationComment; };
template<> struct SCHEMA::predicate<664> { using type = facebook::glean::cpp::schema::Cxx1::DeclarationInTrace; };
template<> struct SCHEMA::predicate<665> { using type = facebook::glean::cpp::schema::Cxx1::DeclarationLocationName; };
template<> struct SCHEMA::predicate<666> { using type = facebook::glean::cpp::schema::Cxx1::DeclarationLocationNameSpan; };
template<> struct SCHEMA::predicate<667> { using type = facebook::glean::cpp::schema::Cxx1::DeclarationNameSpan; };
template<> struct SCHEMA::predicate<668> { using type = facebook::glean::cpp::schema::Cxx1::DeclarationSources; };
template<> struct SCHEMA::predicate<669> { using type = facebook::glean::cpp::schema::Cxx1::DeclarationSrcRange; };
template<> struct SCHEMA::predicate<670> { using type = facebook::glean::cpp::schema::Cxx1::DeclarationTargets; };
template<> struct SCHEMA::predicate<671> { using type = facebook::glean::cpp::schema::Cxx1::DeclarationToUSR; };
template<> struct SCHEMA::predicate<672> { using type = facebook::glean::cpp::schema::Cxx1::Declarations; };
template<> struct SCHEMA::predicate<673> { using type = facebook::glean::cpp::schema::Cxx1::DefToBaseDecl; };
template<> struct SCHEMA::predicate<674> { using type = facebook::glean::cpp::schema::Cxx1::MangledNameHashToDeclaration; };
template<> struct SCHEMA::predicate<675> { using type = facebook::glean::cpp::schema::Cxx1::Same; };
template<> struct SCHEMA::predicate<676> { using type = facebook::glean::cpp::schema::Cxx1::USRToDeclaration; };
template<> struct SCHEMA::predicate<677> { using type = facebook::glean::cpp::schema::Cxx1::FileXRefMap; };
template<> struct SCHEMA::predicate<678> { using type = facebook::glean::cpp::schema::Cxx1::SpellingXRef; };
template<> struct SCHEMA::predicate<679> { using type = facebook::glean::cpp::schema::Cxx1::TargetUses; };
template<> struct SCHEMA::predicate<680> { using type = facebook::glean::cpp::schema::Cxx1::ThriftToCxx; };
template<> struct SCHEMA::predicate<681> { using type = facebook::glean::cpp::schema::Cxx1::XRefIndirectTarget; };
template<> struct SCHEMA::predicate<682> { using type = facebook::glean::cpp::schema::Cxx1::XRefTargets; };
template<> struct SCHEMA::predicate<683> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::LookupNamespaceDeclaration; };
template<> struct SCHEMA::predicate<684> { using type = facebook::glean::cpp::schema::Cxx1::DeclToFamily; };
template<> struct SCHEMA::predicate<685> { using type = facebook::glean::cpp::schema::Cxx1::DeclInRecord; };
template<> struct SCHEMA::predicate<686> { using type = facebook::glean::cpp::schema::Cxx1::DeclInObjcContainer; };
template<> struct SCHEMA::predicate<687> { using type = facebook::glean::cpp::schema::Cxx1::DeclFamilyOf; };
template<> struct SCHEMA::predicate<688> { using type = facebook::glean::cpp::schema::Cxx1::DeclFamily; };
template<> struct SCHEMA::predicate<689> { using type = facebook::glean::cpp::schema::Cxx1::CxxToThrift; };
template<> struct SCHEMA::predicate<690> { using type = facebook::glean::cpp::schema::Cxx1::Attribute; };
template<> struct SCHEMA::predicate<691> { using type = facebook::glean::cpp::schema::Cxx1::RecordDefinition; };
template<> struct SCHEMA::predicate<692> { using type = facebook::glean::cpp::schema::Csharp::UnityPackageToProject; };
template<> struct SCHEMA::predicate<693> { using type = facebook::glean::cpp::schema::Csharp::UnityPackage; };
template<> struct SCHEMA::predicate<694> { using type = facebook::glean::cpp::schema::Csharp::UnityProjectSource; };
template<> struct SCHEMA::predicate<695> { using type = facebook::glean::cpp::schema::Csharp::TypeParameter; };
template<> struct SCHEMA::predicate<696> { using type = facebook::glean::cpp::schema::Csharp::SourceFileToProject; };
template<> struct SCHEMA::predicate<697> { using type = facebook::glean::cpp::schema::Csharp::SolutionToProject; };
template<> struct SCHEMA::predicate<698> { using type = facebook::glean::cpp::schema::Csharp::Solution; };
template<> struct SCHEMA::predicate<699> { using type = facebook::glean::cpp::schema::Csharp::ProjectToSourceFile; };
template<> struct SCHEMA::predicate<700> { using type = facebook::glean::cpp::schema::Csharp::ProjectToSolution; };
template<> struct SCHEMA::predicate<701> { using type = facebook::glean::cpp::schema::Csharp::Project; };
template<> struct SCHEMA::predicate<702> { using type = facebook::glean::cpp::schema::Csharp::Namespace; };
template<> struct SCHEMA::predicate<703> { using type = facebook::glean::cpp::schema::Csharp::NameLowerCase; };
template<> struct SCHEMA::predicate<704> { using type = facebook::glean::cpp::schema::Csharp::Name; };
template<> struct SCHEMA::predicate<705> { using type = facebook::glean::cpp::schema::Csharp::MSBuildProjectSource; };
template<> struct SCHEMA::predicate<706> { using type = facebook::glean::cpp::schema::Csharp::MemberAccessLocation; };
template<> struct SCHEMA::predicate<707> { using type = facebook::glean::cpp::schema::Csharp::MethodInvocationLocation; };
template<> struct SCHEMA::predicate<708> { using type = facebook::glean::cpp::schema::Csharp::Implements; };
template<> struct SCHEMA::predicate<709> { using type = facebook::glean::cpp::schema::Csharp::FunctionPointerType; };
template<> struct SCHEMA::predicate<710> { using type = facebook::glean::cpp::schema::Csharp::FullName; };
template<> struct SCHEMA::predicate<711> { using type = facebook::glean::cpp::schema::Csharp::Class; };
template<> struct SCHEMA::predicate<712> { using type = facebook::glean::cpp::schema::Csharp::Interface; };
template<> struct SCHEMA::predicate<713> { using type = facebook::glean::cpp::schema::Csharp::Record; };
template<> struct SCHEMA::predicate<714> { using type = facebook::glean::cpp::schema::Csharp::Struct; };
template<> struct SCHEMA::predicate<715> { using type = facebook::glean::cpp::schema::Csharp::ArrayType; };
template<> struct SCHEMA::predicate<716> { using type = facebook::glean::cpp::schema::Csharp::DefinitionLocation; };
template<> struct SCHEMA::predicate<717> { using type = facebook::glean::cpp::schema::Csharp::DefinitionLocationName; };
template<> struct SCHEMA::predicate<718> { using type = facebook::glean::cpp::schema::Csharp::FileDefinitions; };
template<> struct SCHEMA::predicate<719> { using type = facebook::glean::cpp::schema::Csharp::FileEntityXRefs; };
template<> struct SCHEMA::predicate<720> { using type = facebook::glean::cpp::schema::Csharp::SearchByName; };
template<> struct SCHEMA::predicate<721> { using type = facebook::glean::cpp::schema::Csharp::Field; };
template<> struct SCHEMA::predicate<722> { using type = facebook::glean::cpp::schema::Csharp::Local; };
template<> struct SCHEMA::predicate<723> { using type = facebook::glean::cpp::schema::Csharp::Method; };
template<> struct SCHEMA::predicate<724> { using type = facebook::glean::cpp::schema::Csharp::ObjectCreationLocation; };
template<> struct SCHEMA::predicate<725> { using type = facebook::glean::cpp::schema::Csharp::Parameter; };
template<> struct SCHEMA::predicate<726> { using type = facebook::glean::cpp::schema::Csharp::PointerType; };
template<> struct SCHEMA::predicate<727> { using type = facebook::glean::cpp::schema::Csharp::Property; };
template<> struct SCHEMA::predicate<728> { using type = facebook::glean::cpp::schema::Csharp::TypeLocation; };
template<> struct SCHEMA::predicate<729> { using type = facebook::glean::cpp::schema::Codemarkup::Yaml::YamlDataAvailable; };
template<> struct SCHEMA::predicate<730> { using type = facebook::glean::cpp::schema::Search::Code::CxxNameLowerCase; };
template<> struct SCHEMA::predicate<731> { using type = facebook::glean::cpp::schema::Search::Code::FlowNameLowerCase; };
template<> struct SCHEMA::predicate<732> { using type = facebook::glean::cpp::schema::Search::Code::HackNameLowerCase; };
template<> struct SCHEMA::predicate<733> { using type = facebook::glean::cpp::schema::Search::Code::PythonNameLowerCase; };
template<> struct SCHEMA::predicate<734> { using type = facebook::glean::cpp::schema::Codemarkup::Types::RangeSpanContains; };
template<> struct SCHEMA::predicate<735> { using type = facebook::glean::cpp::schema::Codemarkup::Scip::LsifKindToKind; };
template<> struct SCHEMA::predicate<736> { using type = facebook::glean::cpp::schema::Codemarkup::Scip::FileXLangSymbolRefs; };
template<> struct SCHEMA::predicate<737> { using type = facebook::glean::cpp::schema::Codemarkup::Python::NonImportPythonDeclarationKind; };
template<> struct SCHEMA::predicate<738> { using type = facebook::glean::cpp::schema::Codemarkup::Python::NonImportPythonDeclarationInfo; };
template<> struct SCHEMA::predicate<739> { using type = facebook::glean::cpp::schema::Codemarkup::Python::ConvertLabel; };
template<> struct SCHEMA::predicate<740> { using type = facebook::glean::cpp::schema::Codemarkup::Pp::PpIncludeXRefLocations; };
template<> struct SCHEMA::predicate<741> { using type = facebook::glean::cpp::schema::Codemarkup::Lsif::LsifKindToKind; };
template<> struct SCHEMA::predicate<742> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackInheritedEntities; };
template<> struct SCHEMA::predicate<743> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackEnumInheritedMembers; };
template<> struct SCHEMA::predicate<744> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::FromHackVisibility; };
template<> struct SCHEMA::predicate<745> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowDocumentationSpan; };
template<> struct SCHEMA::predicate<746> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowDeclarationDocumentation; };
template<> struct SCHEMA::predicate<747> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::FromCxxVisibility; };
template<> struct SCHEMA::predicate<748> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityXMapVariableXRefDeclLocations; };
template<> struct SCHEMA::predicate<749> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationModifiers; };
template<> struct SCHEMA::predicate<750> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclVisibility; };
template<> struct SCHEMA::predicate<751> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclKind; };
template<> struct SCHEMA::predicate<752> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclInfo; };
template<> struct SCHEMA::predicate<753> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDataAvailable; };
template<> struct SCHEMA::predicate<754> { using type = facebook::glean::cpp::schema::Codemarkup::IndexedFile; };
template<> struct SCHEMA::predicate<755> { using type = facebook::glean::cpp::schema::Codemarkup::EntityDataAvailable; };
template<> struct SCHEMA::predicate<756> { using type = facebook::glean::cpp::schema::Codemarkup::Scip::EntityInfo; };
template<> struct SCHEMA::predicate<757> { using type = facebook::glean::cpp::schema::Codemarkup::Scip::ScipEntityDocumentation; };
template<> struct SCHEMA::predicate<758> { using type = facebook::glean::cpp::schema::Codemarkup::Scip::ScipEntityLocation; };
template<> struct SCHEMA::predicate<759> { using type = facebook::glean::cpp::schema::Codemarkup::Scip::ScipEntityUses; };
template<> struct SCHEMA::predicate<760> { using type = facebook::glean::cpp::schema::Codemarkup::Scip::ScipFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<761> { using type = facebook::glean::cpp::schema::Codemarkup::Scip::ScipResolveLocation; };
template<> struct SCHEMA::predicate<762> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonContainsChildEntity; };
template<> struct SCHEMA::predicate<763> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonContainsParentEntity; };
template<> struct SCHEMA::predicate<764> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityComments; };
template<> struct SCHEMA::predicate<765> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityInfo; };
template<> struct SCHEMA::predicate<766> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityKind; };
template<> struct SCHEMA::predicate<767> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityLocation; };
template<> struct SCHEMA::predicate<768> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityModuleName; };
template<> struct SCHEMA::predicate<769> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonEntityUses; };
template<> struct SCHEMA::predicate<770> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonExtendsChildEntity; };
template<> struct SCHEMA::predicate<771> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonExtendsParentEntity; };
template<> struct SCHEMA::predicate<772> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<773> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonModifiers; };
template<> struct SCHEMA::predicate<774> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonResolveLocation; };
template<> struct SCHEMA::predicate<775> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonVisibility; };
template<> struct SCHEMA::predicate<776> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonAnnotation; };
template<> struct SCHEMA::predicate<777> { using type = facebook::glean::cpp::schema::Codemarkup::Pp::PPEntityLocation; };
template<> struct SCHEMA::predicate<778> { using type = facebook::glean::cpp::schema::Codemarkup::Pp::PpEntityInfo; };
template<> struct SCHEMA::predicate<779> { using type = facebook::glean::cpp::schema::Codemarkup::Pp::PpEntityKind; };
template<> struct SCHEMA::predicate<780> { using type = facebook::glean::cpp::schema::Codemarkup::Pp::PpEntityTraceXRefLocations; };
template<> struct SCHEMA::predicate<781> { using type = facebook::glean::cpp::schema::Codemarkup::Pp::PpEntityUses; };
template<> struct SCHEMA::predicate<782> { using type = facebook::glean::cpp::schema::Codemarkup::Pp::PpFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<783> { using type = facebook::glean::cpp::schema::Codemarkup::Pp::PpResolveLocation; };
template<> struct SCHEMA::predicate<784> { using type = facebook::glean::cpp::schema::Codemarkup::Pp::PpResolveTraceLocation; };
template<> struct SCHEMA::predicate<785> { using type = facebook::glean::cpp::schema::Codemarkup::Lsif::EntityInfo; };
template<> struct SCHEMA::predicate<786> { using type = facebook::glean::cpp::schema::Codemarkup::Lsif::LsifEntityLocation; };
template<> struct SCHEMA::predicate<787> { using type = facebook::glean::cpp::schema::Codemarkup::Lsif::LsifEntityModuleName; };
template<> struct SCHEMA::predicate<788> { using type = facebook::glean::cpp::schema::Codemarkup::Lsif::LsifEntityUses; };
template<> struct SCHEMA::predicate<789> { using type = facebook::glean::cpp::schema::Codemarkup::Lsif::LsifFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<790> { using type = facebook::glean::cpp::schema::Codemarkup::Lsif::LsifResolveLocation; };
template<> struct SCHEMA::predicate<791> { using type = facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinContainsChildEntity; };
template<> struct SCHEMA::predicate<792> { using type = facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinContainsParentEntity; };
template<> struct SCHEMA::predicate<793> { using type = facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinEntityKind; };
template<> struct SCHEMA::predicate<794> { using type = facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinEntityLocation; };
template<> struct SCHEMA::predicate<795> { using type = facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinEntityUses; };
template<> struct SCHEMA::predicate<796> { using type = facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinExtendsParentEntity; };
template<> struct SCHEMA::predicate<797> { using type = facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<798> { using type = facebook::glean::cpp::schema::Codemarkup::Kotlin::KotlinResolveLocation; };
template<> struct SCHEMA::predicate<799> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaContainsChildEntity; };
template<> struct SCHEMA::predicate<800> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaContainsParentEntity; };
template<> struct SCHEMA::predicate<801> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaEntityDocumentation; };
template<> struct SCHEMA::predicate<802> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaEntityKind; };
template<> struct SCHEMA::predicate<803> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaEntityLocation; };
template<> struct SCHEMA::predicate<804> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaEntityUses; };
template<> struct SCHEMA::predicate<805> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaExtendsChildEntity; };
template<> struct SCHEMA::predicate<806> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaExtendsParentEntity; };
template<> struct SCHEMA::predicate<807> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaModifiers; };
template<> struct SCHEMA::predicate<808> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaResolveLocation; };
template<> struct SCHEMA::predicate<809> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaVisibility; };
template<> struct SCHEMA::predicate<810> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavalFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<811> { using type = facebook::glean::cpp::schema::Codemarkup::Java::JavaAnnotation; };
template<> struct SCHEMA::predicate<812> { using type = facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellContainsChildEntity; };
template<> struct SCHEMA::predicate<813> { using type = facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellContainsParentEntity; };
template<> struct SCHEMA::predicate<814> { using type = facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellEntityLocation; };
template<> struct SCHEMA::predicate<815> { using type = facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellEntityUses; };
template<> struct SCHEMA::predicate<816> { using type = facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<817> { using type = facebook::glean::cpp::schema::Codemarkup::Haskell::HaskellResolveLocation; };
template<> struct SCHEMA::predicate<818> { using type = facebook::glean::cpp::schema::Search::Hs::SearchByLowerCaseName; };
template<> struct SCHEMA::predicate<819> { using type = facebook::glean::cpp::schema::Search::Hs::SearchByName; };
template<> struct SCHEMA::predicate<820> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::EntityHasHideFromDocsAttr; };
template<> struct SCHEMA::predicate<821> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackContainsChildEntity; };
template<> struct SCHEMA::predicate<822> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackContainsParentEntity; };
template<> struct SCHEMA::predicate<823> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityDocumentation; };
template<> struct SCHEMA::predicate<824> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityInfo; };
template<> struct SCHEMA::predicate<825> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityKind; };
template<> struct SCHEMA::predicate<826> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityLocation; };
template<> struct SCHEMA::predicate<827> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityModuleName; };
template<> struct SCHEMA::predicate<828> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackEntitySource; };
template<> struct SCHEMA::predicate<829> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityUses; };
template<> struct SCHEMA::predicate<830> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackExtendsChildEntity; };
template<> struct SCHEMA::predicate<831> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackExtendsParentEntity; };
template<> struct SCHEMA::predicate<832> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackExtendsParentEntityConcise; };
template<> struct SCHEMA::predicate<833> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<834> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackFileEntityXRefSpans; };
template<> struct SCHEMA::predicate<835> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackModifiers; };
template<> struct SCHEMA::predicate<836> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackRequiredConstraint; };
template<> struct SCHEMA::predicate<837> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackResolveLocation; };
template<> struct SCHEMA::predicate<838> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackVisibility; };
template<> struct SCHEMA::predicate<839> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackAnnotation; };
template<> struct SCHEMA::predicate<840> { using type = facebook::glean::cpp::schema::Codemarkup::Graphql::GraphQLEntityKind; };
template<> struct SCHEMA::predicate<841> { using type = facebook::glean::cpp::schema::Codemarkup::Graphql::GraphQLEntityLocation; };
template<> struct SCHEMA::predicate<842> { using type = facebook::glean::cpp::schema::Codemarkup::Graphql::GraphQLEntityUses; };
template<> struct SCHEMA::predicate<843> { using type = facebook::glean::cpp::schema::Codemarkup::Graphql::GraphQLFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<844> { using type = facebook::glean::cpp::schema::Codemarkup::Graphql::GraphQLResolveLocation; };
template<> struct SCHEMA::predicate<845> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowContainsChildEntity; };
template<> struct SCHEMA::predicate<846> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowContainsParentEntity; };
template<> struct SCHEMA::predicate<847> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowEntityDocumentation; };
template<> struct SCHEMA::predicate<848> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowEntityKind; };
template<> struct SCHEMA::predicate<849> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowEntityLocation; };
template<> struct SCHEMA::predicate<850> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowEntityModuleName; };
template<> struct SCHEMA::predicate<851> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowEntityUses; };
template<> struct SCHEMA::predicate<852> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<853> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowFileImportDeclEntityXRefLocations; };
template<> struct SCHEMA::predicate<854> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowFileReferenceEntityXRefLocations; };
template<> struct SCHEMA::predicate<855> { using type = facebook::glean::cpp::schema::Codemarkup::Flow::FlowResolveLocation; };
template<> struct SCHEMA::predicate<856> { using type = facebook::glean::cpp::schema::Codemarkup::Fbthrift::FbthriftEntityDocumentation; };
template<> struct SCHEMA::predicate<857> { using type = facebook::glean::cpp::schema::Codemarkup::Fbthrift::FbthriftEntityUses; };
template<> struct SCHEMA::predicate<858> { using type = facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftContainsChildEntity; };
template<> struct SCHEMA::predicate<859> { using type = facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftContainsParentEntity; };
template<> struct SCHEMA::predicate<860> { using type = facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftEntityKind; };
template<> struct SCHEMA::predicate<861> { using type = facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftEntityLocation; };
template<> struct SCHEMA::predicate<862> { using type = facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftExtendsChildEntity; };
template<> struct SCHEMA::predicate<863> { using type = facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftExtendsParentEntity; };
template<> struct SCHEMA::predicate<864> { using type = facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<865> { using type = facebook::glean::cpp::schema::Codemarkup::Fbthrift::ThriftResolveLocation; };
template<> struct SCHEMA::predicate<866> { using type = facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangEntityDocumentation; };
template<> struct SCHEMA::predicate<867> { using type = facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangEntityInfo; };
template<> struct SCHEMA::predicate<868> { using type = facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangEntityKind; };
template<> struct SCHEMA::predicate<869> { using type = facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangEntityLocation; };
template<> struct SCHEMA::predicate<870> { using type = facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangEntityUses; };
template<> struct SCHEMA::predicate<871> { using type = facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<872> { using type = facebook::glean::cpp::schema::Codemarkup::Erlang::ErlangResolveLocation; };
template<> struct SCHEMA::predicate<873> { using type = facebook::glean::cpp::schema::Search::Erlang::SearchByFQN; };
template<> struct SCHEMA::predicate<874> { using type = facebook::glean::cpp::schema::Search::Erlang::SearchByName; };
template<> struct SCHEMA::predicate<875> { using type = facebook::glean::cpp::schema::Codemarkup::Dataswarm::DataswarmFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<876> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxContainsChildEntity; };
template<> struct SCHEMA::predicate<877> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxContainsParentEntity; };
template<> struct SCHEMA::predicate<878> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclToDefXRefTargetLocation; };
template<> struct SCHEMA::predicate<879> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationContainsChild; };
template<> struct SCHEMA::predicate<880> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationContainsParent; };
template<> struct SCHEMA::predicate<881> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationExtendsChild; };
template<> struct SCHEMA::predicate<882> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationExtendsParent; };
template<> struct SCHEMA::predicate<883> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDeclarationSource; };
template<> struct SCHEMA::predicate<884> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefToDeclFamilyXRefTargetLocation; };
template<> struct SCHEMA::predicate<885> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityDocumentation; };
template<> struct SCHEMA::predicate<886> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityInfo; };
template<> struct SCHEMA::predicate<887> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityKind; };
template<> struct SCHEMA::predicate<888> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityLocation; };
template<> struct SCHEMA::predicate<889> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityMangledNameHash; };
template<> struct SCHEMA::predicate<890> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntitySource; };
template<> struct SCHEMA::predicate<891> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityUSR; };
template<> struct SCHEMA::predicate<892> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityUses; };
template<> struct SCHEMA::predicate<893> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxExtendsChildEntity; };
template<> struct SCHEMA::predicate<894> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxExtendsParentEntity; };
template<> struct SCHEMA::predicate<895> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntitySpellingXRefLocations; };
template<> struct SCHEMA::predicate<896> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityTraceDeclToDefXRefLocations; };
template<> struct SCHEMA::predicate<897> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityXMapFixedXRefLocations; };
template<> struct SCHEMA::predicate<898> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityXMapVariableXRefDeclToDefs; };
template<> struct SCHEMA::predicate<899> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<900> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFindDefinitionOfEntity; };
template<> struct SCHEMA::predicate<901> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxModifiers; };
template<> struct SCHEMA::predicate<902> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxNamespaceDeclarationContainsChild; };
template<> struct SCHEMA::predicate<903> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxResolveDeclarationToEntity; };
template<> struct SCHEMA::predicate<904> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxResolveLocation; };
template<> struct SCHEMA::predicate<905> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxResolveTraceLocation; };
template<> struct SCHEMA::predicate<906> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxVisibility; };
template<> struct SCHEMA::predicate<907> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxXRefTargetLocation; };
template<> struct SCHEMA::predicate<908> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::EntityToXRefTarget; };
template<> struct SCHEMA::predicate<909> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::SymbolToEntity; };
template<> struct SCHEMA::predicate<910> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::XRefTargetToEntity; };
template<> struct SCHEMA::predicate<911> { using type = facebook::glean::cpp::schema::Search::Code::CxxPreferDefinitions; };
template<> struct SCHEMA::predicate<912> { using type = facebook::glean::cpp::schema::Search::Kind::Cxx::SearchObjcInterface; };
template<> struct SCHEMA::predicate<913> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::DefinitionOfDecl; };
template<> struct SCHEMA::predicate<914> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::LookupNamespaceDefinition; };
template<> struct SCHEMA::predicate<915> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefinitionContainsChild; };
template<> struct SCHEMA::predicate<916> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefinitionContainsParent; };
template<> struct SCHEMA::predicate<917> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefinitionExtendsChild; };
template<> struct SCHEMA::predicate<918> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefinitionExtendsParent; };
template<> struct SCHEMA::predicate<919> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefinitionModifiers; };
template<> struct SCHEMA::predicate<920> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxDefnVisibility; };
template<> struct SCHEMA::predicate<921> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityDefinitionBase; };
template<> struct SCHEMA::predicate<922> { using type = facebook::glean::cpp::schema::Search::Cxx::DeclIsDefn; };
template<> struct SCHEMA::predicate<923> { using type = facebook::glean::cpp::schema::Code::Cxx::DeclToDef; };
template<> struct SCHEMA::predicate<924> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxAnnotation; };
template<> struct SCHEMA::predicate<925> { using type = facebook::glean::cpp::schema::Codemarkup::Csharp::CSharpEntityKind; };
template<> struct SCHEMA::predicate<926> { using type = facebook::glean::cpp::schema::Codemarkup::Csharp::CSharpEntityLocation; };
template<> struct SCHEMA::predicate<927> { using type = facebook::glean::cpp::schema::Codemarkup::Csharp::CSharpEntityUses; };
template<> struct SCHEMA::predicate<928> { using type = facebook::glean::cpp::schema::Codemarkup::Csharp::CSharpFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<929> { using type = facebook::glean::cpp::schema::Codemarkup::Csharp::CSharpResolveLocation; };
template<> struct SCHEMA::predicate<930> { using type = facebook::glean::cpp::schema::Codemarkup::Buck::BuckEntityKind; };
template<> struct SCHEMA::predicate<931> { using type = facebook::glean::cpp::schema::Codemarkup::Buck::BuckEntityLocation; };
template<> struct SCHEMA::predicate<932> { using type = facebook::glean::cpp::schema::Codemarkup::Buck::BuckEntityUses; };
template<> struct SCHEMA::predicate<933> { using type = facebook::glean::cpp::schema::Codemarkup::Buck::BuckFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<934> { using type = facebook::glean::cpp::schema::Codemarkup::Buck::BuckResolveLocation; };
template<> struct SCHEMA::predicate<935> { using type = facebook::glean::cpp::schema::Search::Buck::SearchByFQN; };
template<> struct SCHEMA::predicate<936> { using type = facebook::glean::cpp::schema::Search::Buck::SearchDefinition; };
template<> struct SCHEMA::predicate<937> { using type = facebook::glean::cpp::schema::Search::Buck::SearchFile; };
template<> struct SCHEMA::predicate<938> { using type = facebook::glean::cpp::schema::Code::EntityLanguageSCIP; };
template<> struct SCHEMA::predicate<939> { using type = facebook::glean::cpp::schema::Code::EntityLanguageLSIF; };
template<> struct SCHEMA::predicate<940> { using type = facebook::glean::cpp::schema::Cxx1::FunctionName; };
template<> struct SCHEMA::predicate<941> { using type = facebook::glean::cpp::schema::Cxx1::RecordDeclaration; };
template<> struct SCHEMA::predicate<942> { using type = facebook::glean::cpp::schema::Cxx1::DeclarationScope; };
template<> struct SCHEMA::predicate<943> { using type = facebook::glean::cpp::schema::Cxx1::EnumDeclarationByName; };
template<> struct SCHEMA::predicate<944> { using type = facebook::glean::cpp::schema::Cxx1::FunctionDeclarationByNameScope; };
template<> struct SCHEMA::predicate<945> { using type = facebook::glean::cpp::schema::Cxx1::FunctionQName; };
template<> struct SCHEMA::predicate<946> { using type = facebook::glean::cpp::schema::Cxx1::QName; };
template<> struct SCHEMA::predicate<947> { using type = facebook::glean::cpp::schema::Cxx1::RecordDeclarationClass; };
template<> struct SCHEMA::predicate<948> { using type = facebook::glean::cpp::schema::Cxx1::RecordDeclarationStruct; };
template<> struct SCHEMA::predicate<949> { using type = facebook::glean::cpp::schema::Cxx1::RecordDeclarationUnion; };
template<> struct SCHEMA::predicate<950> { using type = facebook::glean::cpp::schema::Cxx1::TypeAliasDeclarationByName; };
template<> struct SCHEMA::predicate<951> { using type = facebook::glean::cpp::schema::Cxx1::VariableDeclarationNonLocalByName; };
template<> struct SCHEMA::predicate<952> { using type = facebook::glean::cpp::schema::Search::Cxx::QueryToScopeCase; };
template<> struct SCHEMA::predicate<953> { using type = facebook::glean::cpp::schema::Search::Kind::Cxx::SearchClass; };
template<> struct SCHEMA::predicate<954> { using type = facebook::glean::cpp::schema::Search::Kind::Cxx::SearchEnum; };
template<> struct SCHEMA::predicate<955> { using type = facebook::glean::cpp::schema::Search::Kind::Cxx::SearchEnumerator; };
template<> struct SCHEMA::predicate<956> { using type = facebook::glean::cpp::schema::Search::Kind::Cxx::SearchFunction; };
template<> struct SCHEMA::predicate<957> { using type = facebook::glean::cpp::schema::Search::Kind::Cxx::SearchNamespace; };
template<> struct SCHEMA::predicate<958> { using type = facebook::glean::cpp::schema::Search::Kind::Cxx::SearchStruct; };
template<> struct SCHEMA::predicate<959> { using type = facebook::glean::cpp::schema::Search::Kind::Cxx::SearchTypeAlias; };
template<> struct SCHEMA::predicate<960> { using type = facebook::glean::cpp::schema::Search::Kind::Cxx::SearchUnion; };
template<> struct SCHEMA::predicate<961> { using type = facebook::glean::cpp::schema::Search::Kind::Cxx::SearchVariable; };
template<> struct SCHEMA::predicate<962> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::LookupDeclaration; };
template<> struct SCHEMA::predicate<963> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::LookupDefinition; };
template<> struct SCHEMA::predicate<964> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::LookupEnumerator; };
template<> struct SCHEMA::predicate<965> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionDeclaration; };
template<> struct SCHEMA::predicate<966> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionDefinition; };
template<> struct SCHEMA::predicate<967> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionSignatureDeclaration; };
template<> struct SCHEMA::predicate<968> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionSignatureDefinition; };
template<> struct SCHEMA::predicate<969> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionSignatureQualifierDeclaration; };
template<> struct SCHEMA::predicate<970> { using type = facebook::glean::cpp::schema::Symbolid::Cxx::LookupFunctionSignatureQualifierDefinition; };
template<> struct SCHEMA::predicate<971> { using type = facebook::glean::cpp::schema::Fbthrift::FunctionSpecification; };
template<> struct SCHEMA::predicate<972> { using type = facebook::glean::cpp::schema::Buck::Type; };
template<> struct SCHEMA::predicate<973> { using type = facebook::glean::cpp::schema::Buck::TranslationUnit; };
template<> struct SCHEMA::predicate<974> { using type = facebook::glean::cpp::schema::Buck::TargetUses; };
template<> struct SCHEMA::predicate<975> { using type = facebook::glean::cpp::schema::Buck::TargetSourcesBaseModule; };
template<> struct SCHEMA::predicate<976> { using type = facebook::glean::cpp::schema::Buck::TargetSources; };
template<> struct SCHEMA::predicate<977> { using type = facebook::glean::cpp::schema::Buck::TargetOuts; };
template<> struct SCHEMA::predicate<978> { using type = facebook::glean::cpp::schema::Buck::TargetOut; };
template<> struct SCHEMA::predicate<979> { using type = facebook::glean::cpp::schema::Buck::TargetMode; };
template<> struct SCHEMA::predicate<980> { using type = facebook::glean::cpp::schema::Buck::TargetLocation; };
template<> struct SCHEMA::predicate<981> { using type = facebook::glean::cpp::schema::Buck::TargetLinkWhole; };
template<> struct SCHEMA::predicate<982> { using type = facebook::glean::cpp::schema::Buck::TargetIndexerName; };
template<> struct SCHEMA::predicate<983> { using type = facebook::glean::cpp::schema::Buck::TargetIndexer; };
template<> struct SCHEMA::predicate<984> { using type = facebook::glean::cpp::schema::Buck::TargetHash; };
template<> struct SCHEMA::predicate<985> { using type = facebook::glean::cpp::schema::Buck::TargetCallByCallExpr; };
template<> struct SCHEMA::predicate<986> { using type = facebook::glean::cpp::schema::Buck::TargetCall; };
template<> struct SCHEMA::predicate<987> { using type = facebook::glean::cpp::schema::Buck::TargetByType; };
template<> struct SCHEMA::predicate<988> { using type = facebook::glean::cpp::schema::Buck::TargetAttribute; };
template<> struct SCHEMA::predicate<989> { using type = facebook::glean::cpp::schema::Buck::Target; };
template<> struct SCHEMA::predicate<990> { using type = facebook::glean::cpp::schema::Buck::SourceFileLocation; };
template<> struct SCHEMA::predicate<991> { using type = facebook::glean::cpp::schema::Buck::SearchByLocalName; };
template<> struct SCHEMA::predicate<992> { using type = facebook::glean::cpp::schema::Buck::RuleKey; };
template<> struct SCHEMA::predicate<993> { using type = facebook::glean::cpp::schema::Buck::Platform; };
template<> struct SCHEMA::predicate<994> { using type = facebook::glean::cpp::schema::Buck::Owner; };
template<> struct SCHEMA::predicate<995> { using type = facebook::glean::cpp::schema::Buck::OutsTarget; };
template<> struct SCHEMA::predicate<996> { using type = facebook::glean::cpp::schema::Buck::OutputLabel; };
template<> struct SCHEMA::predicate<997> { using type = facebook::glean::cpp::schema::Buck::OutTarget; };
template<> struct SCHEMA::predicate<998> { using type = facebook::glean::cpp::schema::Buck::LocatorWithLabel; };
template<> struct SCHEMA::predicate<999> { using type = facebook::glean::cpp::schema::Buck::LocatorReverseDeps; };
template<> struct SCHEMA::predicate<1000> { using type = facebook::glean::cpp::schema::Buck::LocatorReverseDep; };
template<> struct SCHEMA::predicate<1001> { using type = facebook::glean::cpp::schema::Buck::Locator; };
template<> struct SCHEMA::predicate<1002> { using type = facebook::glean::cpp::schema::Buck::LocalNameLowerCase; };
template<> struct SCHEMA::predicate<1003> { using type = facebook::glean::cpp::schema::Buck::LocalName; };
template<> struct SCHEMA::predicate<1004> { using type = facebook::glean::cpp::schema::Buck::Labels; };
template<> struct SCHEMA::predicate<1005> { using type = facebook::glean::cpp::schema::Buck::Label; };
template<> struct SCHEMA::predicate<1006> { using type = facebook::glean::cpp::schema::Buck::IndexerName; };
template<> struct SCHEMA::predicate<1007> { using type = facebook::glean::cpp::schema::Buck::FileXRefs; };
template<> struct SCHEMA::predicate<1008> { using type = facebook::glean::cpp::schema::Buck::FileToTarget; };
template<> struct SCHEMA::predicate<1009> { using type = facebook::glean::cpp::schema::Buck::FileTarget; };
template<> struct SCHEMA::predicate<1010> { using type = facebook::glean::cpp::schema::Buck::FileResolved; };
template<> struct SCHEMA::predicate<1011> { using type = facebook::glean::cpp::schema::Buck::FileEntity; };
template<> struct SCHEMA::predicate<1012> { using type = facebook::glean::cpp::schema::Buck::FileDefinition; };
template<> struct SCHEMA::predicate<1013> { using type = facebook::glean::cpp::schema::Buck::File; };
template<> struct SCHEMA::predicate<1014> { using type = facebook::glean::cpp::schema::Buck::FailureSources; };
template<> struct SCHEMA::predicate<1015> { using type = facebook::glean::cpp::schema::Buck::IndexFailureX; };
template<> struct SCHEMA::predicate<1016> { using type = facebook::glean::cpp::schema::Buck::DestinationUses; };
template<> struct SCHEMA::predicate<1017> { using type = facebook::glean::cpp::schema::Buck::TargetDependencies; };
template<> struct SCHEMA::predicate<1018> { using type = facebook::glean::cpp::schema::Buck::DefinitionLocation; };
template<> struct SCHEMA::predicate<1019> { using type = facebook::glean::cpp::schema::Buck::Definition; };
template<> struct SCHEMA::predicate<1020> { using type = facebook::glean::cpp::schema::Buck::Consumer; };
template<> struct SCHEMA::predicate<1021> { using type = facebook::glean::cpp::schema::Buck::CallExpr; };
template<> struct SCHEMA::predicate<1022> { using type = facebook::glean::cpp::schema::Buck::CallArgument; };
template<> struct SCHEMA::predicate<1023> { using type = facebook::glean::cpp::schema::Buck::AttributeName; };
template<> struct SCHEMA::predicate<1024> { using type = facebook::glean::cpp::schema::Buck::AttributeValue; };
template<> struct SCHEMA::predicate<1025> { using type = facebook::glean::cpp::schema::Buck::ArgumentValue; };
template<> struct SCHEMA::predicate<1026> { using type = facebook::glean::cpp::schema::Anglelang::TypeDecl; };
template<> struct SCHEMA::predicate<1027> { using type = facebook::glean::cpp::schema::Anglelang::Name; };
template<> struct SCHEMA::predicate<1028> { using type = facebook::glean::cpp::schema::Anglelang::Type; };
template<> struct SCHEMA::predicate<1029> { using type = facebook::glean::cpp::schema::Anglelang::EvolveDecl; };
template<> struct SCHEMA::predicate<1030> { using type = facebook::glean::cpp::schema::Anglelang::DerivingDecl; };
template<> struct SCHEMA::predicate<1031> { using type = facebook::glean::cpp::schema::Anglelang::PredicateDecl; };
template<> struct SCHEMA::predicate<1032> { using type = facebook::glean::cpp::schema::Anglelang::DeclarationLocation; };
template<> struct SCHEMA::predicate<1033> { using type = facebook::glean::cpp::schema::Anglelang::DeclarationToName; };
template<> struct SCHEMA::predicate<1034> { using type = facebook::glean::cpp::schema::Anglelang::SchemaDecl; };
template<> struct SCHEMA::predicate<1035> { using type = facebook::glean::cpp::schema::Anglelang::TargetUses; };
template<> struct SCHEMA::predicate<1036> { using type = facebook::glean::cpp::schema::Anglelang::FileXRefs; };
template<> struct SCHEMA::predicate<1037> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::ConvertCallArguments; };
template<> struct SCHEMA::predicate<1038> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::ConvertMaybeCallArguments; };
template<> struct SCHEMA::predicate<1039> { using type = facebook::glean::cpp::schema::Codemarkup::Python::ConvertCallArguments; };
template<> struct SCHEMA::predicate<1040> { using type = facebook::glean::cpp::schema::Codemarkup::Python::PythonFileCall; };
template<> struct SCHEMA::predicate<1041> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::ConvertArgument; };
template<> struct SCHEMA::predicate<1042> { using type = facebook::glean::cpp::schema::Codemarkup::Python::ConvertArgument; };
template<> struct SCHEMA::predicate<1043> { using type = facebook::glean::cpp::schema::Code::EntityLanguage; };
template<> struct SCHEMA::predicate<1044> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxEntityIdl; };
template<> struct SCHEMA::predicate<1045> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackEntityIdl; };
template<> struct SCHEMA::predicate<1046> { using type = facebook::glean::cpp::schema::Codemarkup::Yaml::YamlFileEntityXLangXRefLocations; };
template<> struct SCHEMA::predicate<1047> { using type = facebook::glean::cpp::schema::Codemarkup::ContainsChildEntity; };
template<> struct SCHEMA::predicate<1048> { using type = facebook::glean::cpp::schema::Codemarkup::ContainsParentEntity; };
template<> struct SCHEMA::predicate<1049> { using type = facebook::glean::cpp::schema::Codemarkup::EntityComments; };
template<> struct SCHEMA::predicate<1050> { using type = facebook::glean::cpp::schema::Codemarkup::EntityInfo; };
template<> struct SCHEMA::predicate<1051> { using type = facebook::glean::cpp::schema::Codemarkup::EntityIsDefinition; };
template<> struct SCHEMA::predicate<1052> { using type = facebook::glean::cpp::schema::Codemarkup::EntityKind; };
template<> struct SCHEMA::predicate<1053> { using type = facebook::glean::cpp::schema::Codemarkup::EntityLocation; };
template<> struct SCHEMA::predicate<1054> { using type = facebook::glean::cpp::schema::Codemarkup::EntityModifiers; };
template<> struct SCHEMA::predicate<1055> { using type = facebook::glean::cpp::schema::Codemarkup::EntityModuleName; };
template<> struct SCHEMA::predicate<1056> { using type = facebook::glean::cpp::schema::Codemarkup::EntityReferences; };
template<> struct SCHEMA::predicate<1057> { using type = facebook::glean::cpp::schema::Codemarkup::EntitySource; };
template<> struct SCHEMA::predicate<1058> { using type = facebook::glean::cpp::schema::Codemarkup::EntityToAnnotations; };
template<> struct SCHEMA::predicate<1059> { using type = facebook::glean::cpp::schema::Codemarkup::EntityUses; };
template<> struct SCHEMA::predicate<1060> { using type = facebook::glean::cpp::schema::Codemarkup::EntityVisibility; };
template<> struct SCHEMA::predicate<1061> { using type = facebook::glean::cpp::schema::Codemarkup::ExtendsChildEntity; };
template<> struct SCHEMA::predicate<1062> { using type = facebook::glean::cpp::schema::Codemarkup::ExtendsParentEntity; };
template<> struct SCHEMA::predicate<1063> { using type = facebook::glean::cpp::schema::Codemarkup::ExtendsParentEntityConcise; };
template<> struct SCHEMA::predicate<1064> { using type = facebook::glean::cpp::schema::Codemarkup::FileCall; };
template<> struct SCHEMA::predicate<1065> { using type = facebook::glean::cpp::schema::Codemarkup::FileEntityDigest; };
template<> struct SCHEMA::predicate<1066> { using type = facebook::glean::cpp::schema::Codemarkup::FileEntityInfos; };
template<> struct SCHEMA::predicate<1067> { using type = facebook::glean::cpp::schema::Codemarkup::FileEntityKinds; };
template<> struct SCHEMA::predicate<1068> { using type = facebook::glean::cpp::schema::Codemarkup::FileEntityLocations; };
template<> struct SCHEMA::predicate<1069> { using type = facebook::glean::cpp::schema::Codemarkup::FileEntityXRefInfos; };
template<> struct SCHEMA::predicate<1070> { using type = facebook::glean::cpp::schema::Codemarkup::FileEntityXRefKinds; };
template<> struct SCHEMA::predicate<1071> { using type = facebook::glean::cpp::schema::Codemarkup::FileEntityXRefLocations; };
template<> struct SCHEMA::predicate<1072> { using type = facebook::glean::cpp::schema::Codemarkup::FileEntityXRefRangeSpans; };
template<> struct SCHEMA::predicate<1073> { using type = facebook::glean::cpp::schema::Codemarkup::FindEntityDefinition; };
template<> struct SCHEMA::predicate<1074> { using type = facebook::glean::cpp::schema::Codemarkup::GeneratedEntityToIdlEntity; };
template<> struct SCHEMA::predicate<1075> { using type = facebook::glean::cpp::schema::Codemarkup::FileXRefsGenericEntities; };
template<> struct SCHEMA::predicate<1076> { using type = facebook::glean::cpp::schema::Codemarkup::SearchRelatedEntities; };
template<> struct SCHEMA::predicate<1077> { using type = facebook::glean::cpp::schema::Codemarkup::ReferencingEntity; };
template<> struct SCHEMA::predicate<1078> { using type = facebook::glean::cpp::schema::Codemarkup::ResolveLocation; };
template<> struct SCHEMA::predicate<1079> { using type = facebook::glean::cpp::schema::Codemarkup::SearchInheritedEntities; };
template<> struct SCHEMA::predicate<1080> { using type = facebook::glean::cpp::schema::Codemarkup::SymbolToEntity; };
template<> struct SCHEMA::predicate<1081> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxFileEntityIdl; };
template<> struct SCHEMA::predicate<1082> { using type = facebook::glean::cpp::schema::Codemarkup::Cxx::CxxIdlEntityUses; };
template<> struct SCHEMA::predicate<1083> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::ConvertCallee; };
template<> struct SCHEMA::predicate<1084> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::ConvertCalleeForFileCall; };
template<> struct SCHEMA::predicate<1085> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::ConvertStaticType; };
template<> struct SCHEMA::predicate<1086> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackFileCall; };
template<> struct SCHEMA::predicate<1087> { using type = facebook::glean::cpp::schema::Codemarkup::Hack::HackIdlEntityUses; };
template<> struct SCHEMA::predicate<1088> { using type = facebook::glean::cpp::schema::Codemarkup::Search::EntityLocationAndKind; };
template<> struct SCHEMA::predicate<1089> { using type = facebook::glean::cpp::schema::Codemarkup::Search::SearchByName; };
template<> struct SCHEMA::predicate<1090> { using type = facebook::glean::cpp::schema::Codemarkup::Search::SearchByScope; };
template<> struct SCHEMA::predicate<1091> { using type = facebook::glean::cpp::schema::Dyn::EntityUsage; };
template<> struct SCHEMA::predicate<1092> { using type = facebook::glean::cpp::schema::Search::Code::AngleSearchByLowerCaseName; };
template<> struct SCHEMA::predicate<1093> { using type = facebook::glean::cpp::schema::Search::Code::AngleSearchByName; };
template<> struct SCHEMA::predicate<1094> { using type = facebook::glean::cpp::schema::Search::Code::BuckSearchByLocalNameFact; };
template<> struct SCHEMA::predicate<1095> { using type = facebook::glean::cpp::schema::Search::Code::BuckSearchByLowerCaseName; };
template<> struct SCHEMA::predicate<1096> { using type = facebook::glean::cpp::schema::Search::Code::BuckSearchByName; };
template<> struct SCHEMA::predicate<1097> { using type = facebook::glean::cpp::schema::Search::Code::CSharpSearchByLowerCaseName; };
template<> struct SCHEMA::predicate<1098> { using type = facebook::glean::cpp::schema::Search::Code::CSharpSearchByName; };
template<> struct SCHEMA::predicate<1099> { using type = facebook::glean::cpp::schema::Search::Code::CxxSearchByLowerCaseNameKindAndScopeFact; };
template<> struct SCHEMA::predicate<1100> { using type = facebook::glean::cpp::schema::Search::Code::CxxSearchByLowerCaseScopeAndKind; };
template<> struct SCHEMA::predicate<1101> { using type = facebook::glean::cpp::schema::Search::Code::CxxSearchByNameKindAndScopeFact; };
template<> struct SCHEMA::predicate<1102> { using type = facebook::glean::cpp::schema::Search::Code::CxxSearchByScopeAndKind; };
template<> struct SCHEMA::predicate<1103> { using type = facebook::glean::cpp::schema::Search::Code::ErlangSearchByLowerCaseName; };
template<> struct SCHEMA::predicate<1104> { using type = facebook::glean::cpp::schema::Search::Code::ErlangSearchByName; };
template<> struct SCHEMA::predicate<1105> { using type = facebook::glean::cpp::schema::Search::Code::FbthriftSearchByNameFact; };
template<> struct SCHEMA::predicate<1106> { using type = facebook::glean::cpp::schema::Search::Code::FlowSearchByLowerCaseNameKindAndScopeFact; };
template<> struct SCHEMA::predicate<1107> { using type = facebook::glean::cpp::schema::Search::Code::FlowSearchByLowerCaseScopeAndKind; };
template<> struct SCHEMA::predicate<1108> { using type = facebook::glean::cpp::schema::Search::Code::FlowSearchByNameKindAndScopeFact; };
template<> struct SCHEMA::predicate<1109> { using type = facebook::glean::cpp::schema::Search::Code::FlowSearchByScopeAndKind; };
template<> struct SCHEMA::predicate<1110> { using type = facebook::glean::cpp::schema::Search::Code::GraphQLSearchByLowerCaseName; };
template<> struct SCHEMA::predicate<1111> { using type = facebook::glean::cpp::schema::Search::Code::GraphQLSearchByName; };
template<> struct SCHEMA::predicate<1112> { using type = facebook::glean::cpp::schema::Search::Code::HackSearchByLowerCaseNameAndKind; };
template<> struct SCHEMA::predicate<1113> { using type = facebook::glean::cpp::schema::Search::Code::HackSearchByLowerCaseScopeAndKind; };
template<> struct SCHEMA::predicate<1114> { using type = facebook::glean::cpp::schema::Search::Code::HackSearchByNameAndKind; };
template<> struct SCHEMA::predicate<1115> { using type = facebook::glean::cpp::schema::Search::Code::HackSearchByNameKindWithNamespace; };
template<> struct SCHEMA::predicate<1116> { using type = facebook::glean::cpp::schema::Search::Code::HackSearchByNameKindWithQName; };
template<> struct SCHEMA::predicate<1117> { using type = facebook::glean::cpp::schema::Search::Code::HackSearchByScopeAndKind; };
template<> struct SCHEMA::predicate<1118> { using type = facebook::glean::cpp::schema::Search::Code::HackSearchByScopeWithNameKinds; };
template<> struct SCHEMA::predicate<1119> { using type = facebook::glean::cpp::schema::Search::Code::HsSearchByLowerCaseName; };
template<> struct SCHEMA::predicate<1120> { using type = facebook::glean::cpp::schema::Search::Code::HsSearchByName; };
template<> struct SCHEMA::predicate<1121> { using type = facebook::glean::cpp::schema::Search::Code::JavaSearchByLowerCaseName; };
template<> struct SCHEMA::predicate<1122> { using type = facebook::glean::cpp::schema::Search::Code::JavaSearchByLowerCaseScope; };
template<> struct SCHEMA::predicate<1123> { using type = facebook::glean::cpp::schema::Search::Code::JavaSearchByName; };
template<> struct SCHEMA::predicate<1124> { using type = facebook::glean::cpp::schema::Search::Code::JavaSearchByNameWithFact; };
template<> struct SCHEMA::predicate<1125> { using type = facebook::glean::cpp::schema::Search::Code::JavaSearchByScope; };
template<> struct SCHEMA::predicate<1126> { using type = facebook::glean::cpp::schema::Search::Code::JavaSearchByScopeWithName; };
template<> struct SCHEMA::predicate<1127> { using type = facebook::glean::cpp::schema::Search::Code::KotlinSearchByLowerCaseName; };
template<> struct SCHEMA::predicate<1128> { using type = facebook::glean::cpp::schema::Search::Code::KotlinSearchByLowerCaseScope; };
template<> struct SCHEMA::predicate<1129> { using type = facebook::glean::cpp::schema::Search::Code::KotlinSearchByName; };
template<> struct SCHEMA::predicate<1130> { using type = facebook::glean::cpp::schema::Search::Code::KotlinSearchByNameWithFact; };
template<> struct SCHEMA::predicate<1131> { using type = facebook::glean::cpp::schema::Search::Code::KotlinSearchByScope; };
template<> struct SCHEMA::predicate<1132> { using type = facebook::glean::cpp::schema::Search::Code::KotlinSearchByScopeWithName; };
template<> struct SCHEMA::predicate<1133> { using type = facebook::glean::cpp::schema::Search::Code::LsifSearchByLowerCaseName; };
template<> struct SCHEMA::predicate<1134> { using type = facebook::glean::cpp::schema::Search::Code::LsifSearchByName; };
template<> struct SCHEMA::predicate<1135> { using type = facebook::glean::cpp::schema::Search::Code::PpSearchByLowerCaseNameKind; };
template<> struct SCHEMA::predicate<1136> { using type = facebook::glean::cpp::schema::Search::Code::PpSearchByNameKind; };
template<> struct SCHEMA::predicate<1137> { using type = facebook::glean::cpp::schema::Search::Code::PythonSearchByLowerCaseNameKindAndScopeFact; };
template<> struct SCHEMA::predicate<1138> { using type = facebook::glean::cpp::schema::Search::Code::PythonSearchByLowerCaseScopeAndKind; };
template<> struct SCHEMA::predicate<1139> { using type = facebook::glean::cpp::schema::Search::Code::PythonSearchByNameKindAndScopeFact; };
template<> struct SCHEMA::predicate<1140> { using type = facebook::glean::cpp::schema::Search::Code::PythonSearchByScopeAndKind; };
template<> struct SCHEMA::predicate<1141> { using type = facebook::glean::cpp::schema::Search::Code::RustSearchByNameAndKind; };
template<> struct SCHEMA::predicate<1142> { using type = facebook::glean::cpp::schema::Search::Code::SearchByLowerCaseNameAndLanguage; };
template<> struct SCHEMA::predicate<1143> { using type = facebook::glean::cpp::schema::Search::Code::SearchByLowerCaseNameKindAndLanguage; };
template<> struct SCHEMA::predicate<1144> { using type = facebook::glean::cpp::schema::Search::Code::SearchByLowerCaseScope; };
template<> struct SCHEMA::predicate<1145> { using type = facebook::glean::cpp::schema::Search::Code::SearchByLowerCaseScopeAndKind; };
template<> struct SCHEMA::predicate<1146> { using type = facebook::glean::cpp::schema::Search::Code::SearchByNameAndLanguage; };
template<> struct SCHEMA::predicate<1147> { using type = facebook::glean::cpp::schema::Search::Code::SearchByNameKindAndLanguage; };
template<> struct SCHEMA::predicate<1148> { using type = facebook::glean::cpp::schema::Search::Code::SearchByScope; };
template<> struct SCHEMA::predicate<1149> { using type = facebook::glean::cpp::schema::Search::Code::SearchByScopeAndKind; };
template<> struct SCHEMA::predicate<1150> { using type = facebook::glean::cpp::schema::Search::Code::ThriftSearchByLowerCaseName; };
template<> struct SCHEMA::predicate<1151> { using type = facebook::glean::cpp::schema::Search::Code::ThriftSearchByName; };
template<> struct SCHEMA::predicate<1152> { using type = facebook::glean::cpp::schema::Codemarkup::Anglelang::AngleEntityLocation; };
template<> struct SCHEMA::predicate<1153> { using type = facebook::glean::cpp::schema::Codemarkup::Anglelang::AngleEntityUses; };
template<> struct SCHEMA::predicate<1154> { using type = facebook::glean::cpp::schema::Codemarkup::Anglelang::AngleFileEntityXRefLocations; };
template<> struct SCHEMA::predicate<1155> { using type = facebook::glean::cpp::schema::Codemarkup::Anglelang::AngleResolveLocation; };
template<> struct SCHEMA::predicate<1156> { using type = facebook::glean::cpp::schema::Search::Anglelang::SearchByName; };


} // namespace schema

} // namespace cpp

} // namespace glean

} // namespace facebook