hydra-0.15.0: src/main/haskell/Hydra/Tinkerpop/Gremlin.hs

-- Note: this is an automatically generated file. Do not edit.

-- | A Gremlin model, based on the Gremlin ANTLR grammar (master branch, as of 2024-06-30).

module Hydra.Tinkerpop.Gremlin where

import qualified Hydra.Core as Core
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci

newtype QueryList =
  QueryList {
    unQueryList :: [Query]}
  deriving (Eq, Ord, Read, Show)

_QueryList = Core.Name "hydra.tinkerpop.gremlin.QueryList"

data Query =
  QueryTraversalSource TraversalSourceQuery |
  QueryRootTraversal RootTraversalQuery |
  QueryToString  |
  QueryEmpty
  deriving (Eq, Ord, Read, Show)

_Query = Core.Name "hydra.tinkerpop.gremlin.Query"

_Query_traversalSource = Core.Name "traversalSource"

_Query_rootTraversal = Core.Name "rootTraversal"

_Query_toString = Core.Name "toString"

_Query_empty = Core.Name "empty"

data TraversalSourceQuery =
  TraversalSourceQuery {
    traversalSourceQuerySource :: TraversalSource,
    traversalSourceQueryTransactionPart :: (Maybe TransactionPart)}
  deriving (Eq, Ord, Read, Show)

_TraversalSourceQuery = Core.Name "hydra.tinkerpop.gremlin.TraversalSourceQuery"

_TraversalSourceQuery_source = Core.Name "source"

_TraversalSourceQuery_transactionPart = Core.Name "transactionPart"

data RootTraversalQuery =
  RootTraversalQuery {
    rootTraversalQueryRoot :: RootTraversal,
    rootTraversalQueryTerminalMethod :: (Maybe TraversalTerminalMethod)}
  deriving (Eq, Ord, Read, Show)

_RootTraversalQuery = Core.Name "hydra.tinkerpop.gremlin.RootTraversalQuery"

_RootTraversalQuery_root = Core.Name "root"

_RootTraversalQuery_terminalMethod = Core.Name "terminalMethod"

newtype TraversalSource =
  TraversalSource {
    unTraversalSource :: [TraversalSourceSelfMethod]}
  deriving (Eq, Ord, Read, Show)

_TraversalSource = Core.Name "hydra.tinkerpop.gremlin.TraversalSource"

data TransactionPart =
  TransactionPartBegin  |
  TransactionPartCommit  |
  TransactionPartRollback
  deriving (Eq, Ord, Read, Show)

_TransactionPart = Core.Name "hydra.tinkerpop.gremlin.TransactionPart"

_TransactionPart_begin = Core.Name "begin"

_TransactionPart_commit = Core.Name "commit"

_TransactionPart_rollback = Core.Name "rollback"

data RootTraversal =
  RootTraversal {
    rootTraversalSource :: TraversalSource,
    rootTraversalSpawnMethod :: TraversalSourceSpawnMethod,
    rootTraversalChained :: [ChainedTraversalElement]}
  deriving (Eq, Ord, Read, Show)

_RootTraversal = Core.Name "hydra.tinkerpop.gremlin.RootTraversal"

_RootTraversal_source = Core.Name "source"

_RootTraversal_spawnMethod = Core.Name "spawnMethod"

_RootTraversal_chained = Core.Name "chained"

data TraversalSourceSelfMethod =
  TraversalSourceSelfMethodWithBulk Bool |
  TraversalSourceSelfMethodWithPath  |
  TraversalSourceSelfMethodWithSack GenericLiteralArgumentAndOptionalTraversalBiFunctionArgument |
  TraversalSourceSelfMethodWithSideEffect StringArgumentAndGenericLiteralArgument |
  TraversalSourceSelfMethodWithStrategies [TraversalStrategy] |
  TraversalSourceSelfMethodWithoutStrategies [Identifier] |
  TraversalSourceSelfMethodWith StringArgumentAndOptionalGenericLiteralArgument
  deriving (Eq, Ord, Read, Show)

_TraversalSourceSelfMethod = Core.Name "hydra.tinkerpop.gremlin.TraversalSourceSelfMethod"

_TraversalSourceSelfMethod_withBulk = Core.Name "withBulk"

_TraversalSourceSelfMethod_withPath = Core.Name "withPath"

_TraversalSourceSelfMethod_withSack = Core.Name "withSack"

_TraversalSourceSelfMethod_withSideEffect = Core.Name "withSideEffect"

_TraversalSourceSelfMethod_withStrategies = Core.Name "withStrategies"

_TraversalSourceSelfMethod_withoutStrategies = Core.Name "withoutStrategies"

_TraversalSourceSelfMethod_with = Core.Name "with"

data GenericLiteralArgumentAndOptionalTraversalBiFunctionArgument =
  GenericLiteralArgumentAndOptionalTraversalBiFunctionArgument {
    genericLiteralArgumentAndOptionalTraversalBiFunctionArgumentLiteral :: GenericLiteralArgument,
    genericLiteralArgumentAndOptionalTraversalBiFunctionArgumentBiFunction :: (Maybe TraversalBiFunctionArgument)}
  deriving (Eq, Ord, Read, Show)

_GenericLiteralArgumentAndOptionalTraversalBiFunctionArgument =
    Core.Name "hydra.tinkerpop.gremlin.GenericLiteralArgumentAndOptionalTraversalBiFunctionArgument"

_GenericLiteralArgumentAndOptionalTraversalBiFunctionArgument_literal = Core.Name "literal"

_GenericLiteralArgumentAndOptionalTraversalBiFunctionArgument_biFunction = Core.Name "biFunction"

data StringArgumentAndGenericLiteralArgument =
  StringArgumentAndGenericLiteralArgument {
    stringArgumentAndGenericLiteralArgumentString :: StringArgument,
    stringArgumentAndGenericLiteralArgumentLiteral :: GenericLiteralArgument}
  deriving (Eq, Ord, Read, Show)

_StringArgumentAndGenericLiteralArgument = Core.Name "hydra.tinkerpop.gremlin.StringArgumentAndGenericLiteralArgument"

_StringArgumentAndGenericLiteralArgument_string = Core.Name "string"

_StringArgumentAndGenericLiteralArgument_literal = Core.Name "literal"

data StringArgumentAndOptionalGenericLiteralArgument =
  StringArgumentAndOptionalGenericLiteralArgument {
    stringArgumentAndOptionalGenericLiteralArgumentString :: StringArgument,
    stringArgumentAndOptionalGenericLiteralArgumentLiteral :: (Maybe GenericLiteralArgument)}
  deriving (Eq, Ord, Read, Show)

_StringArgumentAndOptionalGenericLiteralArgument =
    Core.Name "hydra.tinkerpop.gremlin.StringArgumentAndOptionalGenericLiteralArgument"

_StringArgumentAndOptionalGenericLiteralArgument_string = Core.Name "string"

_StringArgumentAndOptionalGenericLiteralArgument_literal = Core.Name "literal"

data TraversalSourceSpawnMethod =
  TraversalSourceSpawnMethodAddE StringArgumentOrNestedTraversal |
  TraversalSourceSpawnMethodAddV (Maybe StringArgumentOrNestedTraversal) |
  TraversalSourceSpawnMethodE [GenericLiteralArgument] |
  TraversalSourceSpawnMethodV [GenericLiteralArgument] |
  TraversalSourceSpawnMethodMergeV GenericLiteralMapNullableArgumentOrNestedTraversal |
  TraversalSourceSpawnMethodMergeE GenericLiteralMapNullableArgumentOrNestedTraversal |
  TraversalSourceSpawnMethodInject [GenericLiteralArgument] |
  TraversalSourceSpawnMethodIo StringArgument |
  TraversalSourceSpawnMethodCall (Maybe ServiceCall) |
  TraversalSourceSpawnMethodUnion [NestedTraversal]
  deriving (Eq, Ord, Read, Show)

_TraversalSourceSpawnMethod = Core.Name "hydra.tinkerpop.gremlin.TraversalSourceSpawnMethod"

_TraversalSourceSpawnMethod_addE = Core.Name "addE"

_TraversalSourceSpawnMethod_addV = Core.Name "addV"

_TraversalSourceSpawnMethod_e = Core.Name "e"

_TraversalSourceSpawnMethod_v = Core.Name "v"

_TraversalSourceSpawnMethod_mergeV = Core.Name "mergeV"

_TraversalSourceSpawnMethod_mergeE = Core.Name "mergeE"

_TraversalSourceSpawnMethod_inject = Core.Name "inject"

_TraversalSourceSpawnMethod_io = Core.Name "io"

_TraversalSourceSpawnMethod_call = Core.Name "call"

_TraversalSourceSpawnMethod_union = Core.Name "union"

data GenericLiteralMapNullableArgumentOrNestedTraversal =
  GenericLiteralMapNullableArgumentOrNestedTraversalMap GenericLiteralMapNullableArgument |
  GenericLiteralMapNullableArgumentOrNestedTraversalTraversal NestedTraversal
  deriving (Eq, Ord, Read, Show)

_GenericLiteralMapNullableArgumentOrNestedTraversal =
    Core.Name "hydra.tinkerpop.gremlin.GenericLiteralMapNullableArgumentOrNestedTraversal"

_GenericLiteralMapNullableArgumentOrNestedTraversal_map = Core.Name "map"

_GenericLiteralMapNullableArgumentOrNestedTraversal_traversal = Core.Name "traversal"

data ServiceCall =
  ServiceCall {
    serviceCallService :: StringArgument,
    serviceCallArguments :: ServiceArguments}
  deriving (Eq, Ord, Read, Show)

_ServiceCall = Core.Name "hydra.tinkerpop.gremlin.ServiceCall"

_ServiceCall_service = Core.Name "service"

_ServiceCall_arguments = Core.Name "arguments"

data ServiceArguments =
  ServiceArgumentsMap (Maybe GenericLiteralMapArgument) |
  ServiceArgumentsTraversal (Maybe NestedTraversal)
  deriving (Eq, Ord, Read, Show)

_ServiceArguments = Core.Name "hydra.tinkerpop.gremlin.ServiceArguments"

_ServiceArguments_map = Core.Name "map"

_ServiceArguments_traversal = Core.Name "traversal"

data ChainedTraversal =
  ChainedTraversal {
    chainedTraversalFirst :: TraversalMethod,
    chainedTraversalRest :: ChainedTraversalElement}
  deriving (Eq, Ord, Read, Show)

_ChainedTraversal = Core.Name "hydra.tinkerpop.gremlin.ChainedTraversal"

_ChainedTraversal_first = Core.Name "first"

_ChainedTraversal_rest = Core.Name "rest"

data ChainedTraversalElement =
  ChainedTraversalElementMethod TraversalMethod |
  ChainedTraversalElementSelf TraversalSelfMethod
  deriving (Eq, Ord, Read, Show)

_ChainedTraversalElement = Core.Name "hydra.tinkerpop.gremlin.ChainedTraversalElement"

_ChainedTraversalElement_method = Core.Name "method"

_ChainedTraversalElement_self = Core.Name "self"

data NestedTraversal =
  NestedTraversalRoot RootTraversal |
  NestedTraversalChained ChainedTraversal |
  NestedTraversalAnonymous ChainedTraversal
  deriving (Eq, Ord, Read, Show)

_NestedTraversal = Core.Name "hydra.tinkerpop.gremlin.NestedTraversal"

_NestedTraversal_root = Core.Name "root"

_NestedTraversal_chained = Core.Name "chained"

_NestedTraversal_anonymous = Core.Name "anonymous"

data TerminatedTraversal =
  TerminatedTraversal {
    terminatedTraversalRoot :: RootTraversal,
    terminatedTraversalTerminal :: TraversalTerminalMethod}
  deriving (Eq, Ord, Read, Show)

_TerminatedTraversal = Core.Name "hydra.tinkerpop.gremlin.TerminatedTraversal"

_TerminatedTraversal_root = Core.Name "root"

_TerminatedTraversal_terminal = Core.Name "terminal"

data TraversalMethod =
  TraversalMethodV [GenericLiteralArgument] |
  TraversalMethodE [GenericLiteralArgument] |
  TraversalMethodAddE StringArgumentOrNestedTraversal |
  TraversalMethodAddV (Maybe StringArgumentOrNestedTraversal) |
  TraversalMethodMergeE (Maybe GenericLiteralMapNullableArgumentOrNestedTraversal) |
  TraversalMethodMergeV (Maybe GenericLiteralMapNullableArgumentOrNestedTraversal) |
  TraversalMethodAggregate OptionalTraversalScopeArgumentAndStringArgument |
  TraversalMethodAll TraversalPredicate |
  TraversalMethodAnd [NestedTraversal] |
  TraversalMethodAny TraversalPredicate |
  TraversalMethodAs StringArgumentAndOptionalStringLiteralVarargs |
  TraversalMethodBarrier (Maybe TraversalSackMethodArgumentOrIntegerArgument) |
  TraversalMethodBoth [StringNullableArgument] |
  TraversalMethodBothE [StringNullableArgument] |
  TraversalMethodBothV  |
  TraversalMethodBranch NestedTraversal |
  TraversalMethodBy ByArgs |
  TraversalMethodCap StringArgumentAndOptionalStringLiteralVarargs |
  TraversalMethodChoose ChooseArgs |
  TraversalMethodCoalesce [NestedTraversal] |
  TraversalMethodCoin FloatArgument |
  TraversalMethodConjoin StringArgument |
  TraversalMethodConnectedComponent  |
  TraversalMethodConstant GenericLiteralArgument |
  TraversalMethodCount (Maybe TraversalScopeArgument) |
  TraversalMethodCyclicPath  |
  TraversalMethodDedup DedupArgs |
  TraversalMethodDifference GenericLiteralArgument |
  TraversalMethodDisjunct GenericLiteralArgument |
  TraversalMethodDrop  |
  TraversalMethodElementMap [StringNullableArgument] |
  TraversalMethodEmit (Maybe PredicateOrTraversal) |
  TraversalMethodFilter PredicateOrTraversal |
  TraversalMethodFlatMap NestedTraversal |
  TraversalMethodFold (Maybe GenericLiteralArgumentAndTraversalBiFunctionArgument) |
  TraversalMethodFrom FromArgs |
  TraversalMethodGroup (Maybe StringArgument) |
  TraversalMethodGroupCount (Maybe StringArgument) |
  TraversalMethodHas HasArgs |
  TraversalMethodHasId GenericLiteralArgumentAndTraversalPredicate |
  TraversalMethodHasKey TraversalPredicateOrStringLiteralVarargs |
  TraversalMethodHasLabel TraversalPredicateOrStringLiteralVarargs |
  TraversalMethodHasNot StringNullableArgument |
  TraversalMethodHasValue TraversalPredicateOrGenericLiteralArgument |
  TraversalMethodId  |
  TraversalMethodIdentity  |
  TraversalMethodIn [StringNullableArgument] |
  TraversalMethodInE [StringNullableArgument] |
  TraversalMethodIntersect GenericLiteralArgument |
  TraversalMethodInV  |
  TraversalMethodIndex  |
  TraversalMethodInject [GenericLiteralArgument] |
  TraversalMethodIs TraversalPredicateOrGenericLiteralArgument |
  TraversalMethodKey  |
  TraversalMethodLabel  |
  TraversalMethodLimit OptionalTraversalScopeArgumentAndIntegerArgument |
  TraversalMethodLocal NestedTraversal |
  TraversalMethodLoops (Maybe StringArgument) |
  TraversalMethodMap NestedTraversal |
  TraversalMethodMatch [NestedTraversal] |
  TraversalMethodMath StringArgument |
  TraversalMethodMax (Maybe TraversalScopeArgument) |
  TraversalMethodMean (Maybe TraversalScopeArgument) |
  TraversalMethodMin (Maybe TraversalScopeArgument) |
  TraversalMethodNone TraversalPredicate |
  TraversalMethodNot NestedTraversal |
  TraversalMethodOption OptionArgs |
  TraversalMethodOptional NestedTraversal |
  TraversalMethodOr [NestedTraversal] |
  TraversalMethodOrder (Maybe TraversalScopeArgument) |
  TraversalMethodOtherV  |
  TraversalMethodOut [StringNullableArgument] |
  TraversalMethodOutE [StringNullableArgument] |
  TraversalMethodOutV  |
  TraversalMethodPageRank (Maybe FloatArgument) |
  TraversalMethodPath  |
  TraversalMethodPeerPressure  |
  TraversalMethodProfile (Maybe StringArgument) |
  TraversalMethodProject StringArgumentAndOptionalStringLiteralVarargs |
  TraversalMethodProperties [StringNullableArgument] |
  TraversalMethodProperty PropertyArgs |
  TraversalMethodPropertyMap [StringNullableArgument] |
  TraversalMethodRange RangeArgs |
  TraversalMethodRead  |
  TraversalMethodRepeat OptionalStringArgumentAndNestedTraversal |
  TraversalMethodSack (Maybe TraversalBiFunctionArgument) |
  TraversalMethodSample OptionalTraversalScopeArgumentAndIntegerArgument |
  TraversalMethodSelect SelectArgs |
  TraversalMethodCombine GenericLiteralArgument |
  TraversalMethodProduct GenericLiteralArgument |
  TraversalMethodMerge GenericLiteralArgument |
  TraversalMethodShortestPath  |
  TraversalMethodSideEffect NestedTraversal |
  TraversalMethodSimplePath  |
  TraversalMethodSkip OptionalTraversalScopeArgumentAndIntegerArgument |
  TraversalMethodStore StringArgument |
  TraversalMethodSubgraph StringArgument |
  TraversalMethodSum (Maybe TraversalScopeArgument) |
  TraversalMethodTail (Maybe TailArgs) |
  TraversalMethodFail (Maybe StringArgument) |
  TraversalMethodTimes IntegerArgument |
  TraversalMethodTo ToArgs |
  TraversalMethodToE DirectionAndVarargs |
  TraversalMethodToV TraversalDirectionArgument |
  TraversalMethodTree (Maybe StringArgument) |
  TraversalMethodUnfold  |
  TraversalMethodUnion [NestedTraversal] |
  TraversalMethodUntil PredicateOrTraversal |
  TraversalMethodValue  |
  TraversalMethodValueMap ValueMapArgs |
  TraversalMethodValues [StringNullableArgument] |
  TraversalMethodWhere WhereArgs |
  TraversalMethodWith WithArgs |
  TraversalMethodWrite  |
  TraversalMethodElement [StringNullableArgument] |
  TraversalMethodCall ServiceCall |
  TraversalMethodConcat ConcatArgs |
  TraversalMethodAsString (Maybe TraversalScopeArgument) |
  TraversalMethodFormat StringArgument |
  TraversalMethodToUpper (Maybe TraversalScopeArgument) |
  TraversalMethodToLower (Maybe TraversalScopeArgument) |
  TraversalMethodLength (Maybe TraversalScopeArgument) |
  TraversalMethodTrim (Maybe TraversalScopeArgument) |
  TraversalMethodLTrim (Maybe TraversalScopeArgument) |
  TraversalMethodRTrim (Maybe TraversalScopeArgument) |
  TraversalMethodReverse  |
  TraversalMethodReplace ReplaceArgs |
  TraversalMethodSplit SplitArgs |
  TraversalMethodSubstring SubstringArgs |
  TraversalMethodAsDate  |
  TraversalMethodDateAdd DateAddArgs |
  TraversalMethodDateDiff DateDiffArgs
  deriving (Eq, Ord, Read, Show)

_TraversalMethod = Core.Name "hydra.tinkerpop.gremlin.TraversalMethod"

_TraversalMethod_v = Core.Name "v"

_TraversalMethod_e = Core.Name "e"

_TraversalMethod_addE = Core.Name "addE"

_TraversalMethod_addV = Core.Name "addV"

_TraversalMethod_mergeE = Core.Name "mergeE"

_TraversalMethod_mergeV = Core.Name "mergeV"

_TraversalMethod_aggregate = Core.Name "aggregate"

_TraversalMethod_all = Core.Name "all"

_TraversalMethod_and = Core.Name "and"

_TraversalMethod_any = Core.Name "any"

_TraversalMethod_as = Core.Name "as"

_TraversalMethod_barrier = Core.Name "barrier"

_TraversalMethod_both = Core.Name "both"

_TraversalMethod_bothE = Core.Name "bothE"

_TraversalMethod_bothV = Core.Name "bothV"

_TraversalMethod_branch = Core.Name "branch"

_TraversalMethod_by = Core.Name "by"

_TraversalMethod_cap = Core.Name "cap"

_TraversalMethod_choose = Core.Name "choose"

_TraversalMethod_coalesce = Core.Name "coalesce"

_TraversalMethod_coin = Core.Name "coin"

_TraversalMethod_conjoin = Core.Name "conjoin"

_TraversalMethod_connectedComponent = Core.Name "connectedComponent"

_TraversalMethod_constant = Core.Name "constant"

_TraversalMethod_count = Core.Name "count"

_TraversalMethod_cyclicPath = Core.Name "cyclicPath"

_TraversalMethod_dedup = Core.Name "dedup"

_TraversalMethod_difference = Core.Name "difference"

_TraversalMethod_disjunct = Core.Name "disjunct"

_TraversalMethod_drop = Core.Name "drop"

_TraversalMethod_elementMap = Core.Name "elementMap"

_TraversalMethod_emit = Core.Name "emit"

_TraversalMethod_filter = Core.Name "filter"

_TraversalMethod_flatMap = Core.Name "flatMap"

_TraversalMethod_fold = Core.Name "fold"

_TraversalMethod_from = Core.Name "from"

_TraversalMethod_group = Core.Name "group"

_TraversalMethod_groupCount = Core.Name "groupCount"

_TraversalMethod_has = Core.Name "has"

_TraversalMethod_hasId = Core.Name "hasId"

_TraversalMethod_hasKey = Core.Name "hasKey"

_TraversalMethod_hasLabel = Core.Name "hasLabel"

_TraversalMethod_hasNot = Core.Name "hasNot"

_TraversalMethod_hasValue = Core.Name "hasValue"

_TraversalMethod_id = Core.Name "id"

_TraversalMethod_identity = Core.Name "identity"

_TraversalMethod_in = Core.Name "in"

_TraversalMethod_inE = Core.Name "inE"

_TraversalMethod_intersect = Core.Name "intersect"

_TraversalMethod_inV = Core.Name "inV"

_TraversalMethod_index = Core.Name "index"

_TraversalMethod_inject = Core.Name "inject"

_TraversalMethod_is = Core.Name "is"

_TraversalMethod_key = Core.Name "key"

_TraversalMethod_label = Core.Name "label"

_TraversalMethod_limit = Core.Name "limit"

_TraversalMethod_local = Core.Name "local"

_TraversalMethod_loops = Core.Name "loops"

_TraversalMethod_map = Core.Name "map"

_TraversalMethod_match = Core.Name "match"

_TraversalMethod_math = Core.Name "math"

_TraversalMethod_max = Core.Name "max"

_TraversalMethod_mean = Core.Name "mean"

_TraversalMethod_min = Core.Name "min"

_TraversalMethod_none = Core.Name "none"

_TraversalMethod_not = Core.Name "not"

_TraversalMethod_option = Core.Name "option"

_TraversalMethod_optional = Core.Name "optional"

_TraversalMethod_or = Core.Name "or"

_TraversalMethod_order = Core.Name "order"

_TraversalMethod_otherV = Core.Name "otherV"

_TraversalMethod_out = Core.Name "out"

_TraversalMethod_outE = Core.Name "outE"

_TraversalMethod_outV = Core.Name "outV"

_TraversalMethod_pageRank = Core.Name "pageRank"

_TraversalMethod_path = Core.Name "path"

_TraversalMethod_peerPressure = Core.Name "peerPressure"

_TraversalMethod_profile = Core.Name "profile"

_TraversalMethod_project = Core.Name "project"

_TraversalMethod_properties = Core.Name "properties"

_TraversalMethod_property = Core.Name "property"

_TraversalMethod_propertyMap = Core.Name "propertyMap"

_TraversalMethod_range = Core.Name "range"

_TraversalMethod_read = Core.Name "read"

_TraversalMethod_repeat = Core.Name "repeat"

_TraversalMethod_sack = Core.Name "sack"

_TraversalMethod_sample = Core.Name "sample"

_TraversalMethod_select = Core.Name "select"

_TraversalMethod_combine = Core.Name "combine"

_TraversalMethod_product = Core.Name "product"

_TraversalMethod_merge = Core.Name "merge"

_TraversalMethod_shortestPath = Core.Name "shortestPath"

_TraversalMethod_sideEffect = Core.Name "sideEffect"

_TraversalMethod_simplePath = Core.Name "simplePath"

_TraversalMethod_skip = Core.Name "skip"

_TraversalMethod_store = Core.Name "store"

_TraversalMethod_subgraph = Core.Name "subgraph"

_TraversalMethod_sum = Core.Name "sum"

_TraversalMethod_tail = Core.Name "tail"

_TraversalMethod_fail = Core.Name "fail"

_TraversalMethod_times = Core.Name "times"

_TraversalMethod_to = Core.Name "to"

_TraversalMethod_toE = Core.Name "toE"

_TraversalMethod_toV = Core.Name "toV"

_TraversalMethod_tree = Core.Name "tree"

_TraversalMethod_unfold = Core.Name "unfold"

_TraversalMethod_union = Core.Name "union"

_TraversalMethod_until = Core.Name "until"

_TraversalMethod_value = Core.Name "value"

_TraversalMethod_valueMap = Core.Name "valueMap"

_TraversalMethod_values = Core.Name "values"

_TraversalMethod_where = Core.Name "where"

_TraversalMethod_with = Core.Name "with"

_TraversalMethod_write = Core.Name "write"

_TraversalMethod_element = Core.Name "element"

_TraversalMethod_call = Core.Name "call"

_TraversalMethod_concat = Core.Name "concat"

_TraversalMethod_asString = Core.Name "asString"

_TraversalMethod_format = Core.Name "format"

_TraversalMethod_toUpper = Core.Name "toUpper"

_TraversalMethod_toLower = Core.Name "toLower"

_TraversalMethod_length = Core.Name "length"

_TraversalMethod_trim = Core.Name "trim"

_TraversalMethod_lTrim = Core.Name "lTrim"

_TraversalMethod_rTrim = Core.Name "rTrim"

_TraversalMethod_reverse = Core.Name "reverse"

_TraversalMethod_replace = Core.Name "replace"

_TraversalMethod_split = Core.Name "split"

_TraversalMethod_substring = Core.Name "substring"

_TraversalMethod_asDate = Core.Name "asDate"

_TraversalMethod_dateAdd = Core.Name "dateAdd"

_TraversalMethod_dateDiff = Core.Name "dateDiff"

data StringArgumentOrNestedTraversal =
  StringArgumentOrNestedTraversalString StringArgument |
  StringArgumentOrNestedTraversalTraversal NestedTraversal
  deriving (Eq, Ord, Read, Show)

_StringArgumentOrNestedTraversal = Core.Name "hydra.tinkerpop.gremlin.StringArgumentOrNestedTraversal"

_StringArgumentOrNestedTraversal_string = Core.Name "string"

_StringArgumentOrNestedTraversal_traversal = Core.Name "traversal"

data OptionalTraversalScopeArgumentAndStringArgument =
  OptionalTraversalScopeArgumentAndStringArgument {
    optionalTraversalScopeArgumentAndStringArgumentScope :: (Maybe TraversalScopeArgument),
    optionalTraversalScopeArgumentAndStringArgumentString :: StringArgument}
  deriving (Eq, Ord, Read, Show)

_OptionalTraversalScopeArgumentAndStringArgument =
    Core.Name "hydra.tinkerpop.gremlin.OptionalTraversalScopeArgumentAndStringArgument"

_OptionalTraversalScopeArgumentAndStringArgument_scope = Core.Name "scope"

_OptionalTraversalScopeArgumentAndStringArgument_string = Core.Name "string"

data StringArgumentAndOptionalStringLiteralVarargs =
  StringArgumentAndOptionalStringLiteralVarargs {
    stringArgumentAndOptionalStringLiteralVarargsFirst :: StringArgument,
    stringArgumentAndOptionalStringLiteralVarargsRest :: [StringNullableArgument]}
  deriving (Eq, Ord, Read, Show)

_StringArgumentAndOptionalStringLiteralVarargs =
    Core.Name "hydra.tinkerpop.gremlin.StringArgumentAndOptionalStringLiteralVarargs"

_StringArgumentAndOptionalStringLiteralVarargs_first = Core.Name "first"

_StringArgumentAndOptionalStringLiteralVarargs_rest = Core.Name "rest"

data TraversalSackMethodArgumentOrIntegerArgument =
  TraversalSackMethodArgumentOrIntegerArgumentConsumer TraversalSackMethodArgument |
  TraversalSackMethodArgumentOrIntegerArgumentInt IntegerArgument
  deriving (Eq, Ord, Read, Show)

_TraversalSackMethodArgumentOrIntegerArgument =
    Core.Name "hydra.tinkerpop.gremlin.TraversalSackMethodArgumentOrIntegerArgument"

_TraversalSackMethodArgumentOrIntegerArgument_consumer = Core.Name "consumer"

_TraversalSackMethodArgumentOrIntegerArgument_int = Core.Name "int"

data ByArgs =
  ByArgsOrder TraversalOrderArgument |
  ByArgsToken TraversalTokenArgument |
  ByArgsOther ByOtherArgs
  deriving (Eq, Ord, Read, Show)

_ByArgs = Core.Name "hydra.tinkerpop.gremlin.ByArgs"

_ByArgs_order = Core.Name "order"

_ByArgs_token = Core.Name "token"

_ByArgs_other = Core.Name "other"

data ByOtherArgs =
  ByOtherArgsComparator (Maybe TraversalComparatorArgument) |
  ByOtherArgsOther (Maybe TraversalFunctionArgumentOrStringArgumentOrNestedTraversal)
  deriving (Eq, Ord, Read, Show)

_ByOtherArgs = Core.Name "hydra.tinkerpop.gremlin.ByOtherArgs"

_ByOtherArgs_comparator = Core.Name "comparator"

_ByOtherArgs_other = Core.Name "other"

data TraversalFunctionArgumentOrStringArgumentOrNestedTraversal =
  TraversalFunctionArgumentOrStringArgumentOrNestedTraversalFunction TraversalFunctionArgument |
  TraversalFunctionArgumentOrStringArgumentOrNestedTraversalString StringArgument |
  TraversalFunctionArgumentOrStringArgumentOrNestedTraversalTraversal NestedTraversal
  deriving (Eq, Ord, Read, Show)

_TraversalFunctionArgumentOrStringArgumentOrNestedTraversal =
    Core.Name "hydra.tinkerpop.gremlin.TraversalFunctionArgumentOrStringArgumentOrNestedTraversal"

_TraversalFunctionArgumentOrStringArgumentOrNestedTraversal_function = Core.Name "function"

_TraversalFunctionArgumentOrStringArgumentOrNestedTraversal_string = Core.Name "string"

_TraversalFunctionArgumentOrStringArgumentOrNestedTraversal_traversal = Core.Name "traversal"

data ChooseArgs =
  ChooseArgsFunction TraversalFunctionArgument |
  ChooseArgsPredicateTraversal PredicateTraversalArgument |
  ChooseArgsTraversal NestedTraversalArgument
  deriving (Eq, Ord, Read, Show)

_ChooseArgs = Core.Name "hydra.tinkerpop.gremlin.ChooseArgs"

_ChooseArgs_function = Core.Name "function"

_ChooseArgs_predicateTraversal = Core.Name "predicateTraversal"

_ChooseArgs_traversal = Core.Name "traversal"

data PredicateTraversalArgument =
  PredicateTraversalArgument {
    predicateTraversalArgumentPredicate :: TraversalPredicate,
    predicateTraversalArgumentTraversal1 :: NestedTraversal,
    predicateTraversalArgumentTraversal2 :: (Maybe NestedTraversal)}
  deriving (Eq, Ord, Read, Show)

_PredicateTraversalArgument = Core.Name "hydra.tinkerpop.gremlin.PredicateTraversalArgument"

_PredicateTraversalArgument_predicate = Core.Name "predicate"

_PredicateTraversalArgument_traversal1 = Core.Name "traversal1"

_PredicateTraversalArgument_traversal2 = Core.Name "traversal2"

data NestedTraversalArgument =
  NestedTraversalArgument {
    nestedTraversalArgumentTraversal1 :: NestedTraversal,
    nestedTraversalArgumentTraversal2 :: (Maybe NestedTraversal),
    nestedTraversalArgumentTraversal3 :: (Maybe NestedTraversal)}
  deriving (Eq, Ord, Read, Show)

_NestedTraversalArgument = Core.Name "hydra.tinkerpop.gremlin.NestedTraversalArgument"

_NestedTraversalArgument_traversal1 = Core.Name "traversal1"

_NestedTraversalArgument_traversal2 = Core.Name "traversal2"

_NestedTraversalArgument_traversal3 = Core.Name "traversal3"

data DedupArgs =
  DedupArgsScopeString ScopeStringArgument |
  DedupArgsString [StringNullableArgument]
  deriving (Eq, Ord, Read, Show)

_DedupArgs = Core.Name "hydra.tinkerpop.gremlin.DedupArgs"

_DedupArgs_scopeString = Core.Name "scopeString"

_DedupArgs_string = Core.Name "string"

data ScopeStringArgument =
  ScopeStringArgument {
    scopeStringArgumentScope :: TraversalScopeArgument,
    scopeStringArgumentStrings :: [StringNullableArgument]}
  deriving (Eq, Ord, Read, Show)

_ScopeStringArgument = Core.Name "hydra.tinkerpop.gremlin.ScopeStringArgument"

_ScopeStringArgument_scope = Core.Name "scope"

_ScopeStringArgument_strings = Core.Name "strings"

data PredicateOrTraversal =
  PredicateOrTraversalPredicate TraversalPredicate |
  PredicateOrTraversalTraversal NestedTraversal
  deriving (Eq, Ord, Read, Show)

_PredicateOrTraversal = Core.Name "hydra.tinkerpop.gremlin.PredicateOrTraversal"

_PredicateOrTraversal_predicate = Core.Name "predicate"

_PredicateOrTraversal_traversal = Core.Name "traversal"

data GenericLiteralArgumentAndTraversalBiFunctionArgument =
  GenericLiteralArgumentAndTraversalBiFunctionArgument {
    genericLiteralArgumentAndTraversalBiFunctionArgumentLiteral :: GenericLiteralArgument,
    genericLiteralArgumentAndTraversalBiFunctionArgumentBiFunction :: TraversalBiFunctionArgument}
  deriving (Eq, Ord, Read, Show)

_GenericLiteralArgumentAndTraversalBiFunctionArgument =
    Core.Name "hydra.tinkerpop.gremlin.GenericLiteralArgumentAndTraversalBiFunctionArgument"

_GenericLiteralArgumentAndTraversalBiFunctionArgument_literal = Core.Name "literal"

_GenericLiteralArgumentAndTraversalBiFunctionArgument_biFunction = Core.Name "biFunction"

data FromArgs =
  FromArgsString StringArgument |
  FromArgsVertex StructureVertexArgument |
  FromArgsTraversal NestedTraversal
  deriving (Eq, Ord, Read, Show)

_FromArgs = Core.Name "hydra.tinkerpop.gremlin.FromArgs"

_FromArgs_string = Core.Name "string"

_FromArgs_vertex = Core.Name "vertex"

_FromArgs_traversal = Core.Name "traversal"

data HasArgs =
  HasArgsString HasStringArgumentAndOptionalStringLiteralVarargs |
  HasArgsTraversalToken HasTraversalTokenArgs
  deriving (Eq, Ord, Read, Show)

_HasArgs = Core.Name "hydra.tinkerpop.gremlin.HasArgs"

_HasArgs_string = Core.Name "string"

_HasArgs_traversalToken = Core.Name "traversalToken"

data HasStringArgumentAndOptionalStringLiteralVarargs =
  HasStringArgumentAndOptionalStringLiteralVarargs {
    hasStringArgumentAndOptionalStringLiteralVarargsString :: StringNullableArgument,
    hasStringArgumentAndOptionalStringLiteralVarargsRest :: (Maybe HasStringArgumentAndOptionalStringLiteralVarargsRest)}
  deriving (Eq, Ord, Read, Show)

_HasStringArgumentAndOptionalStringLiteralVarargs =
    Core.Name "hydra.tinkerpop.gremlin.HasStringArgumentAndOptionalStringLiteralVarargs"

_HasStringArgumentAndOptionalStringLiteralVarargs_string = Core.Name "string"

_HasStringArgumentAndOptionalStringLiteralVarargs_rest = Core.Name "rest"

data HasStringArgumentAndOptionalStringLiteralVarargsRest =
  HasStringArgumentAndOptionalStringLiteralVarargsRestObject GenericLiteralArgument |
  HasStringArgumentAndOptionalStringLiteralVarargsRestPredicate TraversalPredicate |
  HasStringArgumentAndOptionalStringLiteralVarargsRestStringObject StringNullableArgumentAndGenericLiteralArgument |
  HasStringArgumentAndOptionalStringLiteralVarargsRestStringPredicate StringNullableArgumentAndTraversalPredicate |
  HasStringArgumentAndOptionalStringLiteralVarargsRestTraversal NestedTraversal
  deriving (Eq, Ord, Read, Show)

_HasStringArgumentAndOptionalStringLiteralVarargsRest =
    Core.Name "hydra.tinkerpop.gremlin.HasStringArgumentAndOptionalStringLiteralVarargsRest"

_HasStringArgumentAndOptionalStringLiteralVarargsRest_object = Core.Name "object"

_HasStringArgumentAndOptionalStringLiteralVarargsRest_predicate = Core.Name "predicate"

_HasStringArgumentAndOptionalStringLiteralVarargsRest_stringObject = Core.Name "stringObject"

_HasStringArgumentAndOptionalStringLiteralVarargsRest_stringPredicate = Core.Name "stringPredicate"

_HasStringArgumentAndOptionalStringLiteralVarargsRest_traversal = Core.Name "traversal"

data StringNullableArgumentAndGenericLiteralArgument =
  StringNullableArgumentAndGenericLiteralArgument {
    stringNullableArgumentAndGenericLiteralArgumentString :: StringNullableArgument,
    stringNullableArgumentAndGenericLiteralArgumentLiteral :: GenericLiteralArgument}
  deriving (Eq, Ord, Read, Show)

_StringNullableArgumentAndGenericLiteralArgument =
    Core.Name "hydra.tinkerpop.gremlin.StringNullableArgumentAndGenericLiteralArgument"

_StringNullableArgumentAndGenericLiteralArgument_string = Core.Name "string"

_StringNullableArgumentAndGenericLiteralArgument_literal = Core.Name "literal"

data StringNullableArgumentAndTraversalPredicate =
  StringNullableArgumentAndTraversalPredicate {
    stringNullableArgumentAndTraversalPredicateString :: StringNullableArgument,
    stringNullableArgumentAndTraversalPredicatePredicate :: TraversalPredicate}
  deriving (Eq, Ord, Read, Show)

_StringNullableArgumentAndTraversalPredicate =
    Core.Name "hydra.tinkerpop.gremlin.StringNullableArgumentAndTraversalPredicate"

_StringNullableArgumentAndTraversalPredicate_string = Core.Name "string"

_StringNullableArgumentAndTraversalPredicate_predicate = Core.Name "predicate"

data HasTraversalTokenArgs =
  HasTraversalTokenArgs {
    hasTraversalTokenArgsTraversalToken :: TraversalTokenArgument,
    hasTraversalTokenArgsRest :: HasTraversalTokenArgsRest}
  deriving (Eq, Ord, Read, Show)

_HasTraversalTokenArgs = Core.Name "hydra.tinkerpop.gremlin.HasTraversalTokenArgs"

_HasTraversalTokenArgs_traversalToken = Core.Name "traversalToken"

_HasTraversalTokenArgs_rest = Core.Name "rest"

data HasTraversalTokenArgsRest =
  HasTraversalTokenArgsRestLiteral GenericLiteralArgument |
  HasTraversalTokenArgsRestPredicate TraversalPredicate |
  HasTraversalTokenArgsRestTraversal NestedTraversal
  deriving (Eq, Ord, Read, Show)

_HasTraversalTokenArgsRest = Core.Name "hydra.tinkerpop.gremlin.HasTraversalTokenArgsRest"

_HasTraversalTokenArgsRest_literal = Core.Name "literal"

_HasTraversalTokenArgsRest_predicate = Core.Name "predicate"

_HasTraversalTokenArgsRest_traversal = Core.Name "traversal"

data GenericLiteralArgumentAndTraversalPredicate =
  GenericLiteralArgumentAndTraversalPredicateLiteral GenericLiteralArgument |
  GenericLiteralArgumentAndTraversalPredicatePredicate TraversalPredicate
  deriving (Eq, Ord, Read, Show)

_GenericLiteralArgumentAndTraversalPredicate =
    Core.Name "hydra.tinkerpop.gremlin.GenericLiteralArgumentAndTraversalPredicate"

_GenericLiteralArgumentAndTraversalPredicate_literal = Core.Name "literal"

_GenericLiteralArgumentAndTraversalPredicate_predicate = Core.Name "predicate"

data TraversalPredicateOrStringLiteralVarargs =
  TraversalPredicateOrStringLiteralVarargsPredicate TraversalPredicate |
  TraversalPredicateOrStringLiteralVarargsString [StringNullableArgument]
  deriving (Eq, Ord, Read, Show)

_TraversalPredicateOrStringLiteralVarargs = Core.Name "hydra.tinkerpop.gremlin.TraversalPredicateOrStringLiteralVarargs"

_TraversalPredicateOrStringLiteralVarargs_predicate = Core.Name "predicate"

_TraversalPredicateOrStringLiteralVarargs_string = Core.Name "string"

data TraversalPredicateOrGenericLiteralArgument =
  TraversalPredicateOrGenericLiteralArgumentPredicate TraversalPredicate |
  TraversalPredicateOrGenericLiteralArgumentLiteral [GenericLiteralArgument]
  deriving (Eq, Ord, Read, Show)

_TraversalPredicateOrGenericLiteralArgument =
    Core.Name "hydra.tinkerpop.gremlin.TraversalPredicateOrGenericLiteralArgument"

_TraversalPredicateOrGenericLiteralArgument_predicate = Core.Name "predicate"

_TraversalPredicateOrGenericLiteralArgument_literal = Core.Name "literal"

data OptionArgs =
  OptionArgsPredicateTraversal TraversalPredicateAndNestedTraversal |
  OptionArgsMergeMap TraversalMergeArgumentAndGenericLiteralMapNullableArgument |
  OptionArgsMergeTraversal TraversalMergeArgumentAndNestedTraversal |
  OptionArgsObjectTraversal GenericLiteralArgumentAndNestedTraversal |
  OptionArgsTraversal NestedTraversal
  deriving (Eq, Ord, Read, Show)

_OptionArgs = Core.Name "hydra.tinkerpop.gremlin.OptionArgs"

_OptionArgs_predicateTraversal = Core.Name "predicateTraversal"

_OptionArgs_mergeMap = Core.Name "mergeMap"

_OptionArgs_mergeTraversal = Core.Name "mergeTraversal"

_OptionArgs_objectTraversal = Core.Name "objectTraversal"

_OptionArgs_traversal = Core.Name "traversal"

data TraversalPredicateAndNestedTraversal =
  TraversalPredicateAndNestedTraversal {
    traversalPredicateAndNestedTraversalPredicate :: TraversalPredicate,
    traversalPredicateAndNestedTraversalTraversal :: NestedTraversal}
  deriving (Eq, Ord, Read, Show)

_TraversalPredicateAndNestedTraversal = Core.Name "hydra.tinkerpop.gremlin.TraversalPredicateAndNestedTraversal"

_TraversalPredicateAndNestedTraversal_predicate = Core.Name "predicate"

_TraversalPredicateAndNestedTraversal_traversal = Core.Name "traversal"

data TraversalMergeArgumentAndGenericLiteralMapNullableArgument =
  TraversalMergeArgumentAndGenericLiteralMapNullableArgument {
    traversalMergeArgumentAndGenericLiteralMapNullableArgumentMerge :: TraversalMergeArgument,
    traversalMergeArgumentAndGenericLiteralMapNullableArgumentMap :: GenericLiteralMapNullableArgument,
    traversalMergeArgumentAndGenericLiteralMapNullableArgumentCardinality :: (Maybe TraversalCardinality)}
  deriving (Eq, Ord, Read, Show)

_TraversalMergeArgumentAndGenericLiteralMapNullableArgument =
    Core.Name "hydra.tinkerpop.gremlin.TraversalMergeArgumentAndGenericLiteralMapNullableArgument"

_TraversalMergeArgumentAndGenericLiteralMapNullableArgument_merge = Core.Name "merge"

_TraversalMergeArgumentAndGenericLiteralMapNullableArgument_map = Core.Name "map"

_TraversalMergeArgumentAndGenericLiteralMapNullableArgument_cardinality = Core.Name "cardinality"

data TraversalMergeArgumentAndNestedTraversal =
  TraversalMergeArgumentAndNestedTraversal {
    traversalMergeArgumentAndNestedTraversalMerge :: TraversalMergeArgument,
    traversalMergeArgumentAndNestedTraversalTraversal :: NestedTraversal}
  deriving (Eq, Ord, Read, Show)

_TraversalMergeArgumentAndNestedTraversal = Core.Name "hydra.tinkerpop.gremlin.TraversalMergeArgumentAndNestedTraversal"

_TraversalMergeArgumentAndNestedTraversal_merge = Core.Name "merge"

_TraversalMergeArgumentAndNestedTraversal_traversal = Core.Name "traversal"

data GenericLiteralArgumentAndNestedTraversal =
  GenericLiteralArgumentAndNestedTraversal {
    genericLiteralArgumentAndNestedTraversalObject :: GenericLiteralArgument,
    genericLiteralArgumentAndNestedTraversalTraversal :: NestedTraversal}
  deriving (Eq, Ord, Read, Show)

_GenericLiteralArgumentAndNestedTraversal = Core.Name "hydra.tinkerpop.gremlin.GenericLiteralArgumentAndNestedTraversal"

_GenericLiteralArgumentAndNestedTraversal_object = Core.Name "object"

_GenericLiteralArgumentAndNestedTraversal_traversal = Core.Name "traversal"

data PropertyArgs =
  PropertyArgsCardinalityObjects TraversalCardinalityArgumentAndObjects |
  PropertyArgsObjects [GenericLiteralArgument] |
  PropertyArgsObject GenericLiteralMapNullableArgument |
  PropertyArgsCardinalityObject GenericLiteralMapNullableArgumentAndTraversalCardinalityArgument
  deriving (Eq, Ord, Read, Show)

_PropertyArgs = Core.Name "hydra.tinkerpop.gremlin.PropertyArgs"

_PropertyArgs_cardinalityObjects = Core.Name "cardinalityObjects"

_PropertyArgs_objects = Core.Name "objects"

_PropertyArgs_object = Core.Name "object"

_PropertyArgs_cardinalityObject = Core.Name "cardinalityObject"

data TraversalCardinalityArgumentAndObjects =
  TraversalCardinalityArgumentAndObjects {
    traversalCardinalityArgumentAndObjectsCardinality :: TraversalCardinalityArgument,
    traversalCardinalityArgumentAndObjectsObjects :: [GenericLiteralArgument]}
  deriving (Eq, Ord, Read, Show)

_TraversalCardinalityArgumentAndObjects = Core.Name "hydra.tinkerpop.gremlin.TraversalCardinalityArgumentAndObjects"

_TraversalCardinalityArgumentAndObjects_cardinality = Core.Name "cardinality"

_TraversalCardinalityArgumentAndObjects_objects = Core.Name "objects"

data GenericLiteralMapNullableArgumentAndTraversalCardinalityArgument =
  GenericLiteralMapNullableArgumentAndTraversalCardinalityArgument {
    genericLiteralMapNullableArgumentAndTraversalCardinalityArgumentCardinality :: TraversalCardinalityArgument,
    genericLiteralMapNullableArgumentAndTraversalCardinalityArgumentObject :: GenericLiteralMapNullableArgument}
  deriving (Eq, Ord, Read, Show)

_GenericLiteralMapNullableArgumentAndTraversalCardinalityArgument =
    Core.Name "hydra.tinkerpop.gremlin.GenericLiteralMapNullableArgumentAndTraversalCardinalityArgument"

_GenericLiteralMapNullableArgumentAndTraversalCardinalityArgument_cardinality = Core.Name "cardinality"

_GenericLiteralMapNullableArgumentAndTraversalCardinalityArgument_object = Core.Name "object"

data RangeArgs =
  RangeArgs {
    rangeArgsScope :: (Maybe TraversalScopeArgument),
    rangeArgsMin :: IntegerArgument,
    rangeArgsMax :: IntegerArgument}
  deriving (Eq, Ord, Read, Show)

_RangeArgs = Core.Name "hydra.tinkerpop.gremlin.RangeArgs"

_RangeArgs_scope = Core.Name "scope"

_RangeArgs_min = Core.Name "min"

_RangeArgs_max = Core.Name "max"

data OptionalStringArgumentAndNestedTraversal =
  OptionalStringArgumentAndNestedTraversal {
    optionalStringArgumentAndNestedTraversalString :: (Maybe StringArgument),
    optionalStringArgumentAndNestedTraversalTraversal :: NestedTraversal}
  deriving (Eq, Ord, Read, Show)

_OptionalStringArgumentAndNestedTraversal = Core.Name "hydra.tinkerpop.gremlin.OptionalStringArgumentAndNestedTraversal"

_OptionalStringArgumentAndNestedTraversal_string = Core.Name "string"

_OptionalStringArgumentAndNestedTraversal_traversal = Core.Name "traversal"

data OptionalTraversalScopeArgumentAndIntegerArgument =
  OptionalTraversalScopeArgumentAndIntegerArgument {
    optionalTraversalScopeArgumentAndIntegerArgumentScope :: (Maybe TraversalScopeArgument),
    optionalTraversalScopeArgumentAndIntegerArgumentLong :: IntegerArgument}
  deriving (Eq, Ord, Read, Show)

_OptionalTraversalScopeArgumentAndIntegerArgument =
    Core.Name "hydra.tinkerpop.gremlin.OptionalTraversalScopeArgumentAndIntegerArgument"

_OptionalTraversalScopeArgumentAndIntegerArgument_scope = Core.Name "scope"

_OptionalTraversalScopeArgumentAndIntegerArgument_long = Core.Name "long"

data SelectArgs =
  SelectArgsColumn TraversalColumnArgument |
  SelectArgsPopStrings PopStringsArgument |
  SelectArgsPopTraversal TraversalPopArgumentAndNestedTraversal |
  SelectArgsStrings [StringArgument] |
  SelectArgsTraversal NestedTraversal
  deriving (Eq, Ord, Read, Show)

_SelectArgs = Core.Name "hydra.tinkerpop.gremlin.SelectArgs"

_SelectArgs_column = Core.Name "column"

_SelectArgs_popStrings = Core.Name "popStrings"

_SelectArgs_popTraversal = Core.Name "popTraversal"

_SelectArgs_strings = Core.Name "strings"

_SelectArgs_traversal = Core.Name "traversal"

data PopStringsArgument =
  PopStringsArgument {
    popStringsArgumentPop :: TraversalPopArgument,
    popStringsArgumentString :: [StringArgument]}
  deriving (Eq, Ord, Read, Show)

_PopStringsArgument = Core.Name "hydra.tinkerpop.gremlin.PopStringsArgument"

_PopStringsArgument_pop = Core.Name "pop"

_PopStringsArgument_string = Core.Name "string"

data TraversalPopArgumentAndNestedTraversal =
  TraversalPopArgumentAndNestedTraversal {
    traversalPopArgumentAndNestedTraversalPop :: TraversalPopArgument,
    traversalPopArgumentAndNestedTraversalTraversal :: NestedTraversal}
  deriving (Eq, Ord, Read, Show)

_TraversalPopArgumentAndNestedTraversal = Core.Name "hydra.tinkerpop.gremlin.TraversalPopArgumentAndNestedTraversal"

_TraversalPopArgumentAndNestedTraversal_pop = Core.Name "pop"

_TraversalPopArgumentAndNestedTraversal_traversal = Core.Name "traversal"

data TailArgs =
  TailArgs {
    tailArgsScope :: (Maybe TraversalScopeArgument),
    tailArgsInteger :: (Maybe IntegerArgument)}
  deriving (Eq, Ord, Read, Show)

_TailArgs = Core.Name "hydra.tinkerpop.gremlin.TailArgs"

_TailArgs_scope = Core.Name "scope"

_TailArgs_integer = Core.Name "integer"

data ToArgs =
  ToArgsDirection DirectionAndVarargs |
  ToArgsString StringArgument |
  ToArgsVertex StructureVertexArgument |
  ToArgsTraversal NestedTraversal
  deriving (Eq, Ord, Read, Show)

_ToArgs = Core.Name "hydra.tinkerpop.gremlin.ToArgs"

_ToArgs_direction = Core.Name "direction"

_ToArgs_string = Core.Name "string"

_ToArgs_vertex = Core.Name "vertex"

_ToArgs_traversal = Core.Name "traversal"

data DirectionAndVarargs =
  DirectionAndVarargs {
    directionAndVarargsDirection :: TraversalDirectionArgument,
    directionAndVarargsVarargs :: [StringNullableArgument]}
  deriving (Eq, Ord, Read, Show)

_DirectionAndVarargs = Core.Name "hydra.tinkerpop.gremlin.DirectionAndVarargs"

_DirectionAndVarargs_direction = Core.Name "direction"

_DirectionAndVarargs_varargs = Core.Name "varargs"

data ValueMapArgs =
  ValueMapArgsString [StringNullableArgument] |
  ValueMapArgsBoolean ValueMapBooleanArgs
  deriving (Eq, Ord, Read, Show)

_ValueMapArgs = Core.Name "hydra.tinkerpop.gremlin.ValueMapArgs"

_ValueMapArgs_string = Core.Name "string"

_ValueMapArgs_boolean = Core.Name "boolean"

data ValueMapBooleanArgs =
  ValueMapBooleanArgs {
    valueMapBooleanArgsValue :: BooleanArgument,
    valueMapBooleanArgsKeys :: (Maybe [StringNullableArgument])}
  deriving (Eq, Ord, Read, Show)

_ValueMapBooleanArgs = Core.Name "hydra.tinkerpop.gremlin.ValueMapBooleanArgs"

_ValueMapBooleanArgs_value = Core.Name "value"

_ValueMapBooleanArgs_keys = Core.Name "keys"

data WhereArgs =
  WhereArgsPredicate WhereWithPredicateArgs |
  WhereArgsString StringArgument |
  WhereArgsTraversal NestedTraversal
  deriving (Eq, Ord, Read, Show)

_WhereArgs = Core.Name "hydra.tinkerpop.gremlin.WhereArgs"

_WhereArgs_predicate = Core.Name "predicate"

_WhereArgs_string = Core.Name "string"

_WhereArgs_traversal = Core.Name "traversal"

data WhereWithPredicateArgs =
  WhereWithPredicateArgs {
    whereWithPredicateArgsLeftArg :: (Maybe StringArgument),
    whereWithPredicateArgsPredicate :: TraversalPredicate}
  deriving (Eq, Ord, Read, Show)

_WhereWithPredicateArgs = Core.Name "hydra.tinkerpop.gremlin.WhereWithPredicateArgs"

_WhereWithPredicateArgs_leftArg = Core.Name "leftArg"

_WhereWithPredicateArgs_predicate = Core.Name "predicate"

data WithArgs =
  WithArgs {
    withArgsKeys :: WithArgsKeys,
    withArgsValues :: (Maybe WithArgsValues)}
  deriving (Eq, Ord, Read, Show)

_WithArgs = Core.Name "hydra.tinkerpop.gremlin.WithArgs"

_WithArgs_keys = Core.Name "keys"

_WithArgs_values = Core.Name "values"

data WithArgsKeys =
  WithArgsKeysWithOption WithOptionKeys |
  WithArgsKeysString StringArgument
  deriving (Eq, Ord, Read, Show)

_WithArgsKeys = Core.Name "hydra.tinkerpop.gremlin.WithArgsKeys"

_WithArgsKeys_withOption = Core.Name "withOption"

_WithArgsKeys_string = Core.Name "string"

data WithArgsValues =
  WithArgsValuesWithOptions WithOptionsValues |
  WithArgsValuesIo IoOptionsValues |
  WithArgsValuesObject GenericLiteralArgument
  deriving (Eq, Ord, Read, Show)

_WithArgsValues = Core.Name "hydra.tinkerpop.gremlin.WithArgsValues"

_WithArgsValues_withOptions = Core.Name "withOptions"

_WithArgsValues_io = Core.Name "io"

_WithArgsValues_object = Core.Name "object"

data ConcatArgs =
  ConcatArgsTraversal [NestedTraversal] |
  ConcatArgsString [StringNullableArgument]
  deriving (Eq, Ord, Read, Show)

_ConcatArgs = Core.Name "hydra.tinkerpop.gremlin.ConcatArgs"

_ConcatArgs_traversal = Core.Name "traversal"

_ConcatArgs_string = Core.Name "string"

data ReplaceArgs =
  ReplaceArgs {
    replaceArgsScope :: (Maybe TraversalScopeArgument),
    replaceArgsFrom :: StringNullableArgument,
    replaceArgsTo :: StringNullableArgument}
  deriving (Eq, Ord, Read, Show)

_ReplaceArgs = Core.Name "hydra.tinkerpop.gremlin.ReplaceArgs"

_ReplaceArgs_scope = Core.Name "scope"

_ReplaceArgs_from = Core.Name "from"

_ReplaceArgs_to = Core.Name "to"

data SplitArgs =
  SplitArgs {
    splitArgsScope :: (Maybe TraversalScopeArgument),
    splitArgsDelimiter :: StringNullableArgument}
  deriving (Eq, Ord, Read, Show)

_SplitArgs = Core.Name "hydra.tinkerpop.gremlin.SplitArgs"

_SplitArgs_scope = Core.Name "scope"

_SplitArgs_delimiter = Core.Name "delimiter"

data SubstringArgs =
  SubstringArgs {
    substringArgsScope :: (Maybe TraversalScopeArgument),
    substringArgsStart :: IntegerArgument,
    substringArgsEnd :: (Maybe IntegerArgument)}
  deriving (Eq, Ord, Read, Show)

_SubstringArgs = Core.Name "hydra.tinkerpop.gremlin.SubstringArgs"

_SubstringArgs_scope = Core.Name "scope"

_SubstringArgs_start = Core.Name "start"

_SubstringArgs_end = Core.Name "end"

data DateAddArgs =
  DateAddArgs {
    dateAddArgsUnit :: TraversalDTArgument,
    dateAddArgsDuration :: IntegerArgument}
  deriving (Eq, Ord, Read, Show)

_DateAddArgs = Core.Name "hydra.tinkerpop.gremlin.DateAddArgs"

_DateAddArgs_unit = Core.Name "unit"

_DateAddArgs_duration = Core.Name "duration"

data DateDiffArgs =
  DateDiffArgsTraversal NestedTraversal |
  DateDiffArgsDate DateArgument
  deriving (Eq, Ord, Read, Show)

_DateDiffArgs = Core.Name "hydra.tinkerpop.gremlin.DateDiffArgs"

_DateDiffArgs_traversal = Core.Name "traversal"

_DateDiffArgs_date = Core.Name "date"

data StructureVertex =
  StructureVertex {
    structureVertexNew :: Bool,
    structureVertexId :: GenericLiteralArgument,
    structureVertexLabel :: StringArgument}
  deriving (Eq, Ord, Read, Show)

_StructureVertex = Core.Name "hydra.tinkerpop.gremlin.StructureVertex"

_StructureVertex_new = Core.Name "new"

_StructureVertex_id = Core.Name "id"

_StructureVertex_label = Core.Name "label"

data TraversalStrategy =
  TraversalStrategy {
    traversalStrategyNew :: Bool,
    traversalStrategyClass :: Identifier,
    traversalStrategyConfigurations :: [Configuration]}
  deriving (Eq, Ord, Read, Show)

_TraversalStrategy = Core.Name "hydra.tinkerpop.gremlin.TraversalStrategy"

_TraversalStrategy_new = Core.Name "new"

_TraversalStrategy_class = Core.Name "class"

_TraversalStrategy_configurations = Core.Name "configurations"

data Configuration =
  Configuration {
    configurationKey :: KeywordOrIdentifier,
    configurationValue :: GenericLiteralArgument}
  deriving (Eq, Ord, Read, Show)

_Configuration = Core.Name "hydra.tinkerpop.gremlin.Configuration"

_Configuration_key = Core.Name "key"

_Configuration_value = Core.Name "value"

data KeywordOrIdentifier =
  KeywordOrIdentifierKeyword Keyword |
  KeywordOrIdentifierIdentifier Identifier
  deriving (Eq, Ord, Read, Show)

_KeywordOrIdentifier = Core.Name "hydra.tinkerpop.gremlin.KeywordOrIdentifier"

_KeywordOrIdentifier_keyword = Core.Name "keyword"

_KeywordOrIdentifier_identifier = Core.Name "identifier"

data TraversalScope =
  TraversalScopeLocal  |
  TraversalScopeGlobal
  deriving (Eq, Ord, Read, Show)

_TraversalScope = Core.Name "hydra.tinkerpop.gremlin.TraversalScope"

_TraversalScope_local = Core.Name "local"

_TraversalScope_global = Core.Name "global"

data TraversalToken =
  TraversalTokenId  |
  TraversalTokenLabel  |
  TraversalTokenKey  |
  TraversalTokenValue
  deriving (Eq, Ord, Read, Show)

_TraversalToken = Core.Name "hydra.tinkerpop.gremlin.TraversalToken"

_TraversalToken_id = Core.Name "id"

_TraversalToken_label = Core.Name "label"

_TraversalToken_key = Core.Name "key"

_TraversalToken_value = Core.Name "value"

data TraversalMerge =
  TraversalMergeOnCreate  |
  TraversalMergeOnMatch  |
  TraversalMergeOutV  |
  TraversalMergeInV
  deriving (Eq, Ord, Read, Show)

_TraversalMerge = Core.Name "hydra.tinkerpop.gremlin.TraversalMerge"

_TraversalMerge_onCreate = Core.Name "onCreate"

_TraversalMerge_onMatch = Core.Name "onMatch"

_TraversalMerge_outV = Core.Name "outV"

_TraversalMerge_inV = Core.Name "inV"

data TraversalOrder =
  TraversalOrderIncr  |
  TraversalOrderDecr  |
  TraversalOrderAsc  |
  TraversalOrderDesc  |
  TraversalOrderShuffle
  deriving (Eq, Ord, Read, Show)

_TraversalOrder = Core.Name "hydra.tinkerpop.gremlin.TraversalOrder"

_TraversalOrder_incr = Core.Name "incr"

_TraversalOrder_decr = Core.Name "decr"

_TraversalOrder_asc = Core.Name "asc"

_TraversalOrder_desc = Core.Name "desc"

_TraversalOrder_shuffle = Core.Name "shuffle"

data TraversalDirection =
  TraversalDirectionIn  |
  TraversalDirectionOut  |
  TraversalDirectionBoth
  deriving (Eq, Ord, Read, Show)

_TraversalDirection = Core.Name "hydra.tinkerpop.gremlin.TraversalDirection"

_TraversalDirection_in = Core.Name "in"

_TraversalDirection_out = Core.Name "out"

_TraversalDirection_both = Core.Name "both"

data TraversalCardinality =
  TraversalCardinalitySingle GenericLiteral |
  TraversalCardinalitySet GenericLiteral |
  TraversalCardinalityList GenericLiteral
  deriving (Eq, Ord, Read, Show)

_TraversalCardinality = Core.Name "hydra.tinkerpop.gremlin.TraversalCardinality"

_TraversalCardinality_single = Core.Name "single"

_TraversalCardinality_set = Core.Name "set"

_TraversalCardinality_list = Core.Name "list"

data TraversalColumn =
  TraversalColumnKeys  |
  TraversalColumnValues
  deriving (Eq, Ord, Read, Show)

_TraversalColumn = Core.Name "hydra.tinkerpop.gremlin.TraversalColumn"

_TraversalColumn_keys = Core.Name "keys"

_TraversalColumn_values = Core.Name "values"

data TraversalPop =
  TraversalPopFirst  |
  TraversalPopLast  |
  TraversalPopAll  |
  TraversalPopMixed
  deriving (Eq, Ord, Read, Show)

_TraversalPop = Core.Name "hydra.tinkerpop.gremlin.TraversalPop"

_TraversalPop_first = Core.Name "first"

_TraversalPop_last = Core.Name "last"

_TraversalPop_all = Core.Name "all"

_TraversalPop_mixed = Core.Name "mixed"

data TraversalOperator =
  TraversalOperatorAddAll  |
  TraversalOperatorAnd  |
  TraversalOperatorAssign  |
  TraversalOperatorDiv  |
  TraversalOperatorMax  |
  TraversalOperatorMin  |
  TraversalOperatorMinus  |
  TraversalOperatorMult  |
  TraversalOperatorOr  |
  TraversalOperatorSum  |
  TraversalOperatorSumLong
  deriving (Eq, Ord, Read, Show)

_TraversalOperator = Core.Name "hydra.tinkerpop.gremlin.TraversalOperator"

_TraversalOperator_addAll = Core.Name "addAll"

_TraversalOperator_and = Core.Name "and"

_TraversalOperator_assign = Core.Name "assign"

_TraversalOperator_div = Core.Name "div"

_TraversalOperator_max = Core.Name "max"

_TraversalOperator_min = Core.Name "min"

_TraversalOperator_minus = Core.Name "minus"

_TraversalOperator_mult = Core.Name "mult"

_TraversalOperator_or = Core.Name "or"

_TraversalOperator_sum = Core.Name "sum"

_TraversalOperator_sumLong = Core.Name "sumLong"

data TraversalPick =
  TraversalPickAny  |
  TraversalPickNone
  deriving (Eq, Ord, Read, Show)

_TraversalPick = Core.Name "hydra.tinkerpop.gremlin.TraversalPick"

_TraversalPick_any = Core.Name "any"

_TraversalPick_none = Core.Name "none"

data TraversalDT =
  TraversalDTSecond  |
  TraversalDTMinute  |
  TraversalDTHour  |
  TraversalDTDay
  deriving (Eq, Ord, Read, Show)

_TraversalDT = Core.Name "hydra.tinkerpop.gremlin.TraversalDT"

_TraversalDT_second = Core.Name "second"

_TraversalDT_minute = Core.Name "minute"

_TraversalDT_hour = Core.Name "hour"

_TraversalDT_day = Core.Name "day"

data TraversalPredicate =
  TraversalPredicateEq GenericLiteralArgument |
  TraversalPredicateNeq GenericLiteralArgument |
  TraversalPredicateLt GenericLiteralArgument |
  TraversalPredicateLte GenericLiteralArgument |
  TraversalPredicateGt GenericLiteralArgument |
  TraversalPredicateGte GenericLiteralArgument |
  TraversalPredicateInside RangeArgument |
  TraversalPredicateOutside RangeArgument |
  TraversalPredicateBetween RangeArgument |
  TraversalPredicateWithin (Maybe GenericLiteralArgument) |
  TraversalPredicateWithout (Maybe GenericLiteralArgument) |
  TraversalPredicateNot TraversalPredicate |
  TraversalPredicateStartingWith StringArgument |
  TraversalPredicateNotStartingWith StringArgument |
  TraversalPredicateEndingWith StringArgument |
  TraversalPredicateNotEndingWith StringArgument |
  TraversalPredicateContaining StringArgument |
  TraversalPredicateNotContaining StringArgument |
  TraversalPredicateRegex StringArgument |
  TraversalPredicateNotRegex StringArgument |
  TraversalPredicateAnd TwoTraversalPredicates |
  TraversalPredicateOr TwoTraversalPredicates |
  TraversalPredicateNegate TraversalPredicate
  deriving (Eq, Ord, Read, Show)

_TraversalPredicate = Core.Name "hydra.tinkerpop.gremlin.TraversalPredicate"

_TraversalPredicate_eq = Core.Name "eq"

_TraversalPredicate_neq = Core.Name "neq"

_TraversalPredicate_lt = Core.Name "lt"

_TraversalPredicate_lte = Core.Name "lte"

_TraversalPredicate_gt = Core.Name "gt"

_TraversalPredicate_gte = Core.Name "gte"

_TraversalPredicate_inside = Core.Name "inside"

_TraversalPredicate_outside = Core.Name "outside"

_TraversalPredicate_between = Core.Name "between"

_TraversalPredicate_within = Core.Name "within"

_TraversalPredicate_without = Core.Name "without"

_TraversalPredicate_not = Core.Name "not"

_TraversalPredicate_startingWith = Core.Name "startingWith"

_TraversalPredicate_notStartingWith = Core.Name "notStartingWith"

_TraversalPredicate_endingWith = Core.Name "endingWith"

_TraversalPredicate_notEndingWith = Core.Name "notEndingWith"

_TraversalPredicate_containing = Core.Name "containing"

_TraversalPredicate_notContaining = Core.Name "notContaining"

_TraversalPredicate_regex = Core.Name "regex"

_TraversalPredicate_notRegex = Core.Name "notRegex"

_TraversalPredicate_and = Core.Name "and"

_TraversalPredicate_or = Core.Name "or"

_TraversalPredicate_negate = Core.Name "negate"

data TwoTraversalPredicates =
  TwoTraversalPredicates {
    twoTraversalPredicatesLeft :: TraversalPredicate,
    twoTraversalPredicatesRight :: TraversalPredicate}
  deriving (Eq, Ord, Read, Show)

_TwoTraversalPredicates = Core.Name "hydra.tinkerpop.gremlin.TwoTraversalPredicates"

_TwoTraversalPredicates_left = Core.Name "left"

_TwoTraversalPredicates_right = Core.Name "right"

data TraversalTerminalMethod =
  TraversalTerminalMethodExplain  |
  TraversalTerminalMethodIterate  |
  TraversalTerminalMethodHasNext  |
  TraversalTerminalMethodTryNext  |
  TraversalTerminalMethodNext (Maybe IntegerLiteral) |
  TraversalTerminalMethodToList  |
  TraversalTerminalMethodToSet  |
  TraversalTerminalMethodToBulkSet
  deriving (Eq, Ord, Read, Show)

_TraversalTerminalMethod = Core.Name "hydra.tinkerpop.gremlin.TraversalTerminalMethod"

_TraversalTerminalMethod_explain = Core.Name "explain"

_TraversalTerminalMethod_iterate = Core.Name "iterate"

_TraversalTerminalMethod_hasNext = Core.Name "hasNext"

_TraversalTerminalMethod_tryNext = Core.Name "tryNext"

_TraversalTerminalMethod_next = Core.Name "next"

_TraversalTerminalMethod_toList = Core.Name "toList"

_TraversalTerminalMethod_toSet = Core.Name "toSet"

_TraversalTerminalMethod_toBulkSet = Core.Name "toBulkSet"

data TraversalSelfMethod =
  TraversalSelfMethodDiscard
  deriving (Eq, Ord, Read, Show)

_TraversalSelfMethod = Core.Name "hydra.tinkerpop.gremlin.TraversalSelfMethod"

_TraversalSelfMethod_discard = Core.Name "discard"

data TraversalFunction =
  TraversalFunctionToken TraversalToken |
  TraversalFunctionColumn TraversalColumn
  deriving (Eq, Ord, Read, Show)

_TraversalFunction = Core.Name "hydra.tinkerpop.gremlin.TraversalFunction"

_TraversalFunction_token = Core.Name "token"

_TraversalFunction_column = Core.Name "column"

data RangeArgument =
  RangeArgument {
    rangeArgumentMin :: GenericLiteralArgument,
    rangeArgumentMax :: GenericLiteralArgument}
  deriving (Eq, Ord, Read, Show)

_RangeArgument = Core.Name "hydra.tinkerpop.gremlin.RangeArgument"

_RangeArgument_min = Core.Name "min"

_RangeArgument_max = Core.Name "max"

data WithOptionKeys =
  WithOptionKeysShortestPath ShortestPathConstants |
  WithOptionKeysConnectedComponent ConnectedComponentConstants |
  WithOptionKeysPageRank PageRankConstants |
  WithOptionKeysPeerPressure PeerPressureConstants |
  WithOptionKeysIo IoOptionsKeys |
  WithOptionKeysWithOptionsTokens  |
  WithOptionKeysWithOptionsIndexer
  deriving (Eq, Ord, Read, Show)

_WithOptionKeys = Core.Name "hydra.tinkerpop.gremlin.WithOptionKeys"

_WithOptionKeys_shortestPath = Core.Name "shortestPath"

_WithOptionKeys_connectedComponent = Core.Name "connectedComponent"

_WithOptionKeys_pageRank = Core.Name "pageRank"

_WithOptionKeys_peerPressure = Core.Name "peerPressure"

_WithOptionKeys_io = Core.Name "io"

_WithOptionKeys_withOptionsTokens = Core.Name "withOptionsTokens"

_WithOptionKeys_withOptionsIndexer = Core.Name "withOptionsIndexer"

data ConnectedComponentConstants =
  ConnectedComponentConstantsComponent  |
  ConnectedComponentConstantsEdges  |
  ConnectedComponentConstantsPropertyName
  deriving (Eq, Ord, Read, Show)

_ConnectedComponentConstants = Core.Name "hydra.tinkerpop.gremlin.ConnectedComponentConstants"

_ConnectedComponentConstants_component = Core.Name "component"

_ConnectedComponentConstants_edges = Core.Name "edges"

_ConnectedComponentConstants_propertyName = Core.Name "propertyName"

data PageRankConstants =
  PageRankConstantsEdges  |
  PageRankConstantsTimes  |
  PageRankConstantsPropertyName
  deriving (Eq, Ord, Read, Show)

_PageRankConstants = Core.Name "hydra.tinkerpop.gremlin.PageRankConstants"

_PageRankConstants_edges = Core.Name "edges"

_PageRankConstants_times = Core.Name "times"

_PageRankConstants_propertyName = Core.Name "propertyName"

data PeerPressureConstants =
  PeerPressureConstantsEdges  |
  PeerPressureConstantsTimes  |
  PeerPressureConstantsPropertyName
  deriving (Eq, Ord, Read, Show)

_PeerPressureConstants = Core.Name "hydra.tinkerpop.gremlin.PeerPressureConstants"

_PeerPressureConstants_edges = Core.Name "edges"

_PeerPressureConstants_times = Core.Name "times"

_PeerPressureConstants_propertyName = Core.Name "propertyName"

data ShortestPathConstants =
  ShortestPathConstantsTarget  |
  ShortestPathConstantsEdges  |
  ShortestPathConstantsDistance  |
  ShortestPathConstantsMaxDistance  |
  ShortestPathConstantsIncludeEdges
  deriving (Eq, Ord, Read, Show)

_ShortestPathConstants = Core.Name "hydra.tinkerpop.gremlin.ShortestPathConstants"

_ShortestPathConstants_target = Core.Name "target"

_ShortestPathConstants_edges = Core.Name "edges"

_ShortestPathConstants_distance = Core.Name "distance"

_ShortestPathConstants_maxDistance = Core.Name "maxDistance"

_ShortestPathConstants_includeEdges = Core.Name "includeEdges"

data WithOptionsValues =
  WithOptionsValuesTokens  |
  WithOptionsValuesNone  |
  WithOptionsValuesIds  |
  WithOptionsValuesLabels  |
  WithOptionsValuesKeys  |
  WithOptionsValuesValues  |
  WithOptionsValuesAll  |
  WithOptionsValuesList  |
  WithOptionsValuesMap
  deriving (Eq, Ord, Read, Show)

_WithOptionsValues = Core.Name "hydra.tinkerpop.gremlin.WithOptionsValues"

_WithOptionsValues_tokens = Core.Name "tokens"

_WithOptionsValues_none = Core.Name "none"

_WithOptionsValues_ids = Core.Name "ids"

_WithOptionsValues_labels = Core.Name "labels"

_WithOptionsValues_keys = Core.Name "keys"

_WithOptionsValues_values = Core.Name "values"

_WithOptionsValues_all = Core.Name "all"

_WithOptionsValues_list = Core.Name "list"

_WithOptionsValues_map = Core.Name "map"

data IoOptionsKeys =
  IoOptionsKeysReader  |
  IoOptionsKeysWriter
  deriving (Eq, Ord, Read, Show)

_IoOptionsKeys = Core.Name "hydra.tinkerpop.gremlin.IoOptionsKeys"

_IoOptionsKeys_reader = Core.Name "reader"

_IoOptionsKeys_writer = Core.Name "writer"

data IoOptionsValues =
  IoOptionsValuesGryo  |
  IoOptionsValuesGraphson  |
  IoOptionsValuesGraphml
  deriving (Eq, Ord, Read, Show)

_IoOptionsValues = Core.Name "hydra.tinkerpop.gremlin.IoOptionsValues"

_IoOptionsValues_gryo = Core.Name "gryo"

_IoOptionsValues_graphson = Core.Name "graphson"

_IoOptionsValues_graphml = Core.Name "graphml"

data BooleanArgument =
  BooleanArgumentValue Bool |
  BooleanArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_BooleanArgument = Core.Name "hydra.tinkerpop.gremlin.BooleanArgument"

_BooleanArgument_value = Core.Name "value"

_BooleanArgument_variable = Core.Name "variable"

data IntegerArgument =
  IntegerArgumentValue IntegerLiteral |
  IntegerArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_IntegerArgument = Core.Name "hydra.tinkerpop.gremlin.IntegerArgument"

_IntegerArgument_value = Core.Name "value"

_IntegerArgument_variable = Core.Name "variable"

data FloatArgument =
  FloatArgumentValue FloatLiteral |
  FloatArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_FloatArgument = Core.Name "hydra.tinkerpop.gremlin.FloatArgument"

_FloatArgument_value = Core.Name "value"

_FloatArgument_variable = Core.Name "variable"

data StringArgument =
  StringArgumentValue String |
  StringArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_StringArgument = Core.Name "hydra.tinkerpop.gremlin.StringArgument"

_StringArgument_value = Core.Name "value"

_StringArgument_variable = Core.Name "variable"

data StringNullableArgument =
  StringNullableArgumentValue (Maybe String) |
  StringNullableArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_StringNullableArgument = Core.Name "hydra.tinkerpop.gremlin.StringNullableArgument"

_StringNullableArgument_value = Core.Name "value"

_StringNullableArgument_variable = Core.Name "variable"

data DateArgument =
  DateArgumentValue DateLiteral |
  DateArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_DateArgument = Core.Name "hydra.tinkerpop.gremlin.DateArgument"

_DateArgument_value = Core.Name "value"

_DateArgument_variable = Core.Name "variable"

data GenericLiteralArgument =
  GenericLiteralArgumentValue GenericLiteral |
  GenericLiteralArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_GenericLiteralArgument = Core.Name "hydra.tinkerpop.gremlin.GenericLiteralArgument"

_GenericLiteralArgument_value = Core.Name "value"

_GenericLiteralArgument_variable = Core.Name "variable"

data GenericLiteralListArgument =
  GenericLiteralListArgumentValue GenericLiteralList |
  GenericLiteralListArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_GenericLiteralListArgument = Core.Name "hydra.tinkerpop.gremlin.GenericLiteralListArgument"

_GenericLiteralListArgument_value = Core.Name "value"

_GenericLiteralListArgument_variable = Core.Name "variable"

data GenericLiteralMapArgument =
  GenericLiteralMapArgumentValue GenericLiteralMap |
  GenericLiteralMapArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_GenericLiteralMapArgument = Core.Name "hydra.tinkerpop.gremlin.GenericLiteralMapArgument"

_GenericLiteralMapArgument_value = Core.Name "value"

_GenericLiteralMapArgument_variable = Core.Name "variable"

data GenericLiteralMapNullableArgument =
  GenericLiteralMapNullableArgumentValue (Maybe GenericLiteralMap) |
  GenericLiteralMapNullableArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_GenericLiteralMapNullableArgument = Core.Name "hydra.tinkerpop.gremlin.GenericLiteralMapNullableArgument"

_GenericLiteralMapNullableArgument_value = Core.Name "value"

_GenericLiteralMapNullableArgument_variable = Core.Name "variable"

data StructureVertexArgument =
  StructureVertexArgumentValue StructureVertex |
  StructureVertexArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_StructureVertexArgument = Core.Name "hydra.tinkerpop.gremlin.StructureVertexArgument"

_StructureVertexArgument_value = Core.Name "value"

_StructureVertexArgument_variable = Core.Name "variable"

data TraversalCardinalityArgument =
  TraversalCardinalityArgumentValue TraversalCardinality |
  TraversalCardinalityArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalCardinalityArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalCardinalityArgument"

_TraversalCardinalityArgument_value = Core.Name "value"

_TraversalCardinalityArgument_variable = Core.Name "variable"

data TraversalColumnArgument =
  TraversalColumnArgumentValue TraversalColumn |
  TraversalColumnArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalColumnArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalColumnArgument"

_TraversalColumnArgument_value = Core.Name "value"

_TraversalColumnArgument_variable = Core.Name "variable"

data TraversalDirectionArgument =
  TraversalDirectionArgumentValue TraversalDirection |
  TraversalDirectionArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalDirectionArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalDirectionArgument"

_TraversalDirectionArgument_value = Core.Name "value"

_TraversalDirectionArgument_variable = Core.Name "variable"

data TraversalMergeArgument =
  TraversalMergeArgumentValue TraversalMerge |
  TraversalMergeArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalMergeArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalMergeArgument"

_TraversalMergeArgument_value = Core.Name "value"

_TraversalMergeArgument_variable = Core.Name "variable"

data TraversalOrderArgument =
  TraversalOrderArgumentValue TraversalOrder |
  TraversalOrderArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalOrderArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalOrderArgument"

_TraversalOrderArgument_value = Core.Name "value"

_TraversalOrderArgument_variable = Core.Name "variable"

data TraversalPopArgument =
  TraversalPopArgumentValue TraversalPop |
  TraversalPopArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalPopArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalPopArgument"

_TraversalPopArgument_value = Core.Name "value"

_TraversalPopArgument_variable = Core.Name "variable"

data TraversalSackMethodArgument =
  TraversalSackMethodArgumentValue  |
  TraversalSackMethodArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalSackMethodArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalSackMethodArgument"

_TraversalSackMethodArgument_value = Core.Name "value"

_TraversalSackMethodArgument_variable = Core.Name "variable"

data TraversalScopeArgument =
  TraversalScopeArgumentValue TraversalScope |
  TraversalScopeArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalScopeArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalScopeArgument"

_TraversalScopeArgument_value = Core.Name "value"

_TraversalScopeArgument_variable = Core.Name "variable"

data TraversalTokenArgument =
  TraversalTokenArgumentValue TraversalToken |
  TraversalTokenArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalTokenArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalTokenArgument"

_TraversalTokenArgument_value = Core.Name "value"

_TraversalTokenArgument_variable = Core.Name "variable"

data TraversalComparatorArgument =
  TraversalComparatorArgumentValue TraversalOrder |
  TraversalComparatorArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalComparatorArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalComparatorArgument"

_TraversalComparatorArgument_value = Core.Name "value"

_TraversalComparatorArgument_variable = Core.Name "variable"

data TraversalFunctionArgument =
  TraversalFunctionArgumentValue TraversalFunction |
  TraversalFunctionArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalFunctionArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalFunctionArgument"

_TraversalFunctionArgument_value = Core.Name "value"

_TraversalFunctionArgument_variable = Core.Name "variable"

data TraversalBiFunctionArgument =
  TraversalBiFunctionArgumentValue TraversalOperator |
  TraversalBiFunctionArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalBiFunctionArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalBiFunctionArgument"

_TraversalBiFunctionArgument_value = Core.Name "value"

_TraversalBiFunctionArgument_variable = Core.Name "variable"

data TraversalDTArgument =
  TraversalDTArgumentValue TraversalDT |
  TraversalDTArgumentVariable Identifier
  deriving (Eq, Ord, Read, Show)

_TraversalDTArgument = Core.Name "hydra.tinkerpop.gremlin.TraversalDTArgument"

_TraversalDTArgument_value = Core.Name "value"

_TraversalDTArgument_variable = Core.Name "variable"

newtype GenericLiteralList =
  GenericLiteralList {
    unGenericLiteralList :: [GenericLiteral]}
  deriving (Eq, Ord, Read, Show)

_GenericLiteralList = Core.Name "hydra.tinkerpop.gremlin.GenericLiteralList"

data GenericLiteralRange =
  GenericLiteralRangeInteger IntegerRange |
  GenericLiteralRangeString StringRange
  deriving (Eq, Ord, Read, Show)

_GenericLiteralRange = Core.Name "hydra.tinkerpop.gremlin.GenericLiteralRange"

_GenericLiteralRange_integer = Core.Name "integer"

_GenericLiteralRange_string = Core.Name "string"

data IntegerRange =
  IntegerRange {
    integerRangeLeft :: IntegerLiteral,
    integerRangeRight :: IntegerLiteral}
  deriving (Eq, Ord, Read, Show)

_IntegerRange = Core.Name "hydra.tinkerpop.gremlin.IntegerRange"

_IntegerRange_left = Core.Name "left"

_IntegerRange_right = Core.Name "right"

data StringRange =
  StringRange {
    stringRangeLeft :: String,
    stringRangeRight :: String}
  deriving (Eq, Ord, Read, Show)

_StringRange = Core.Name "hydra.tinkerpop.gremlin.StringRange"

_StringRange_left = Core.Name "left"

_StringRange_right = Core.Name "right"

newtype GenericLiteralSet =
  GenericLiteralSet {
    unGenericLiteralSet :: [GenericLiteral]}
  deriving (Eq, Ord, Read, Show)

_GenericLiteralSet = Core.Name "hydra.tinkerpop.gremlin.GenericLiteralSet"

newtype GenericLiteralCollection =
  GenericLiteralCollection {
    unGenericLiteralCollection :: [GenericLiteral]}
  deriving (Eq, Ord, Read, Show)

_GenericLiteralCollection = Core.Name "hydra.tinkerpop.gremlin.GenericLiteralCollection"

data GenericLiteral =
  GenericLiteralNumeric NumericLiteral |
  GenericLiteralBoolean Bool |
  GenericLiteralString String |
  GenericLiteralDate DateLiteral |
  GenericLiteralNull  |
  GenericLiteralNan  |
  GenericLiteralInf  |
  GenericLiteralTraversalToken TraversalToken |
  GenericLiteralTraversalCardinality TraversalCardinality |
  GenericLiteralTraversalDirection TraversalDirection |
  GenericLiteralTraversalMerge TraversalMerge |
  GenericLiteralTraversalPick TraversalPick |
  GenericLiteralTraversalDT TraversalDT |
  GenericLiteralStructureVertex StructureVertex |
  GenericLiteralGenericLiteralSet GenericLiteralSet |
  GenericLiteralGenericLiteralCollection GenericLiteralCollection |
  GenericLiteralGenericLiteralRange GenericLiteralRange |
  GenericLiteralNestedTraversal NestedTraversal |
  GenericLiteralTerminatedTraversal TerminatedTraversal |
  GenericLiteralGenericLiteralMap GenericLiteralMap
  deriving (Eq, Ord, Read, Show)

_GenericLiteral = Core.Name "hydra.tinkerpop.gremlin.GenericLiteral"

_GenericLiteral_numeric = Core.Name "numeric"

_GenericLiteral_boolean = Core.Name "boolean"

_GenericLiteral_string = Core.Name "string"

_GenericLiteral_date = Core.Name "date"

_GenericLiteral_null = Core.Name "null"

_GenericLiteral_nan = Core.Name "nan"

_GenericLiteral_inf = Core.Name "inf"

_GenericLiteral_traversalToken = Core.Name "traversalToken"

_GenericLiteral_traversalCardinality = Core.Name "traversalCardinality"

_GenericLiteral_traversalDirection = Core.Name "traversalDirection"

_GenericLiteral_traversalMerge = Core.Name "traversalMerge"

_GenericLiteral_traversalPick = Core.Name "traversalPick"

_GenericLiteral_traversalDT = Core.Name "traversalDT"

_GenericLiteral_structureVertex = Core.Name "structureVertex"

_GenericLiteral_genericLiteralSet = Core.Name "genericLiteralSet"

_GenericLiteral_genericLiteralCollection = Core.Name "genericLiteralCollection"

_GenericLiteral_genericLiteralRange = Core.Name "genericLiteralRange"

_GenericLiteral_nestedTraversal = Core.Name "nestedTraversal"

_GenericLiteral_terminatedTraversal = Core.Name "terminatedTraversal"

_GenericLiteral_genericLiteralMap = Core.Name "genericLiteralMap"

newtype GenericLiteralMap =
  GenericLiteralMap {
    unGenericLiteralMap :: [MapEntry]}
  deriving (Eq, Ord, Read, Show)

_GenericLiteralMap = Core.Name "hydra.tinkerpop.gremlin.GenericLiteralMap"

data MapEntry =
  MapEntryKey MapKey |
  MapEntryValue GenericLiteral
  deriving (Eq, Ord, Read, Show)

_MapEntry = Core.Name "hydra.tinkerpop.gremlin.MapEntry"

_MapEntry_key = Core.Name "key"

_MapEntry_value = Core.Name "value"

data MapKey =
  MapKeyString String |
  MapKeyNumeric NumericLiteral |
  MapKeyTraversalToken TraversalToken |
  MapKeyTraversalDirection TraversalDirection |
  MapKeySet GenericLiteralSet |
  MapKeyCollection GenericLiteralCollection |
  MapKeyMap GenericLiteralMap |
  MapKeyKeyword Keyword |
  MapKeyIdentifier Identifier
  deriving (Eq, Ord, Read, Show)

_MapKey = Core.Name "hydra.tinkerpop.gremlin.MapKey"

_MapKey_string = Core.Name "string"

_MapKey_numeric = Core.Name "numeric"

_MapKey_traversalToken = Core.Name "traversalToken"

_MapKey_traversalDirection = Core.Name "traversalDirection"

_MapKey_set = Core.Name "set"

_MapKey_collection = Core.Name "collection"

_MapKey_map = Core.Name "map"

_MapKey_keyword = Core.Name "keyword"

_MapKey_identifier = Core.Name "identifier"

newtype IntegerLiteral =
  IntegerLiteral {
    unIntegerLiteral :: Integer}
  deriving (Eq, Ord, Read, Show)

_IntegerLiteral = Core.Name "hydra.tinkerpop.gremlin.IntegerLiteral"

newtype FloatLiteral =
  FloatLiteral {
    unFloatLiteral :: Double}
  deriving (Eq, Ord, Read, Show)

_FloatLiteral = Core.Name "hydra.tinkerpop.gremlin.FloatLiteral"

data NumericLiteral =
  NumericLiteralInteger IntegerLiteral |
  NumericLiteralFloat FloatLiteral
  deriving (Eq, Ord, Read, Show)

_NumericLiteral = Core.Name "hydra.tinkerpop.gremlin.NumericLiteral"

_NumericLiteral_integer = Core.Name "integer"

_NumericLiteral_float = Core.Name "float"

newtype DateLiteral =
  DateLiteral {
    unDateLiteral :: (Maybe StringArgument)}
  deriving (Eq, Ord, Read, Show)

_DateLiteral = Core.Name "hydra.tinkerpop.gremlin.DateLiteral"

data Keyword =
  KeywordEdges  |
  KeywordKeys  |
  KeywordNew  |
  KeywordValues
  deriving (Eq, Ord, Read, Show)

_Keyword = Core.Name "hydra.tinkerpop.gremlin.Keyword"

_Keyword_edges = Core.Name "edges"

_Keyword_keys = Core.Name "keys"

_Keyword_new = Core.Name "new"

_Keyword_values = Core.Name "values"

newtype Identifier =
  Identifier {
    unIdentifier :: String}
  deriving (Eq, Ord, Read, Show)

_Identifier = Core.Name "hydra.tinkerpop.gremlin.Identifier"