hydra-pg-0.18.0: src/main/haskell/Hydra/Pg/Dsl/Model.hs

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

-- | DSL functions for hydra.pg.model

module Hydra.Pg.Dsl.Model where

import qualified Hydra.Core.Errors as Errors
import qualified Hydra.Core.Graph as Graph
import qualified Hydra.Core.Model as CoreModel
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Pg.Decode.Model as DecodeModel
import qualified Hydra.Pg.Encode.Model as EncodeModel
import qualified Hydra.Pg.Model as PgModel
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void
import qualified Data.Map as M

-- | DSL constructor for hydra.pg.model.AdjacentEdge
adjacentEdge :: Typed.TypedTerm PgModel.EdgeLabel -> Typed.TypedTerm v -> Typed.TypedTerm v -> Typed.TypedTerm (M.Map PgModel.PropertyKey v) -> Typed.TypedTerm (PgModel.AdjacentEdge v)
adjacentEdge label id vertex properties =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (Typed.unTypedTerm label)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (Typed.unTypedTerm id)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (Typed.unTypedTerm vertex)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (Typed.unTypedTerm properties)}]}))

-- | DSL name token for hydra.pg.model.AdjacentEdge
adjacentEdgeAdjacentEdge :: Typed.TypedName (PgModel.AdjacentEdge v)
adjacentEdgeAdjacentEdge = Typed.TypedName (CoreModel.Name "hydra.pg.model.AdjacentEdge")

-- | DSL accessor for the id field of hydra.pg.model.AdjacentEdge
adjacentEdgeId :: Typed.TypedTerm (PgModel.AdjacentEdge v) -> Typed.TypedTerm v
adjacentEdgeId x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
        CoreModel.projectionFieldName = (CoreModel.Name "id")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the label field of hydra.pg.model.AdjacentEdge
adjacentEdgeLabel :: Typed.TypedTerm (PgModel.AdjacentEdge v) -> Typed.TypedTerm PgModel.EdgeLabel
adjacentEdgeLabel x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
        CoreModel.projectionFieldName = (CoreModel.Name "label")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the properties field of hydra.pg.model.AdjacentEdge
adjacentEdgeProperties :: Typed.TypedTerm (PgModel.AdjacentEdge v) -> Typed.TypedTerm (M.Map PgModel.PropertyKey v)
adjacentEdgeProperties x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
        CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the vertex field of hydra.pg.model.AdjacentEdge
adjacentEdgeVertex :: Typed.TypedTerm (PgModel.AdjacentEdge v) -> Typed.TypedTerm v
adjacentEdgeVertex x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
        CoreModel.projectionFieldName = (CoreModel.Name "vertex")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the id field of hydra.pg.model.AdjacentEdge
adjacentEdgeWithId :: Typed.TypedTerm (PgModel.AdjacentEdge v) -> Typed.TypedTerm v -> Typed.TypedTerm (PgModel.AdjacentEdge v)
adjacentEdgeWithId original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "vertex")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the label field of hydra.pg.model.AdjacentEdge
adjacentEdgeWithLabel :: Typed.TypedTerm (PgModel.AdjacentEdge v) -> Typed.TypedTerm PgModel.EdgeLabel -> Typed.TypedTerm (PgModel.AdjacentEdge v)
adjacentEdgeWithLabel original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "vertex")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the properties field of hydra.pg.model.AdjacentEdge
adjacentEdgeWithProperties :: Typed.TypedTerm (PgModel.AdjacentEdge v) -> Typed.TypedTerm (M.Map PgModel.PropertyKey v) -> Typed.TypedTerm (PgModel.AdjacentEdge v)
adjacentEdgeWithProperties original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "vertex")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the vertex field of hydra.pg.model.AdjacentEdge
adjacentEdgeWithVertex :: Typed.TypedTerm (PgModel.AdjacentEdge v) -> Typed.TypedTerm v -> Typed.TypedTerm (PgModel.AdjacentEdge v)
adjacentEdgeWithVertex original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.AdjacentEdge"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL composition builder for the decoder of hydra.pg.model.AdjacentEdge
decodeAdjacentEdge :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.AdjacentEdge v))
decodeAdjacentEdge v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.adjacentEdge")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the decoder of hydra.pg.model.Edge
decodeEdge :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.Edge v))
decodeEdge v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.edge")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the decoder of hydra.pg.model.EdgeType
decodeEdgeType :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError t) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.EdgeType t))
decodeEdgeType t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.edgeType")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the decoder of hydra.pg.model.Element
decodeElement :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.Element v))
decodeElement v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.element")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the decoder of hydra.pg.model.ElementTree
decodeElementTree :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.ElementTree v))
decodeElementTree v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.elementTree")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the decoder of hydra.pg.model.ElementType
decodeElementType :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError t) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.ElementType t))
decodeElementType t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.elementType")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the decoder of hydra.pg.model.ElementTypeTree
decodeElementTypeTree :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError t) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.ElementTypeTree t))
decodeElementTypeTree t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.elementTypeTree")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the decoder of hydra.pg.model.Graph
decodeGraph :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.Graph v))
decodeGraph v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.graph")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the decoder of hydra.pg.model.GraphSchema
decodeGraphSchema :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError t) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.GraphSchema t))
decodeGraphSchema t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.graphSchema")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the decoder of hydra.pg.model.LazyGraph
decodeLazyGraph :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.LazyGraph v))
decodeLazyGraph v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.lazyGraph")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the decoder of hydra.pg.model.Property
decodeProperty :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.Property v))
decodeProperty v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.property")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the decoder of hydra.pg.model.PropertyType
decodePropertyType :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError t) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.PropertyType t))
decodePropertyType t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.propertyType")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the decoder of hydra.pg.model.Vertex
decodeVertex :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.Vertex v))
decodeVertex v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.vertex")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the decoder of hydra.pg.model.VertexType
decodeVertexType :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError t) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.VertexType t))
decodeVertexType t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.vertexType")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the decoder of hydra.pg.model.VertexWithAdjacentEdges
decodeVertexWithAdjacentEdges :: Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> CoreModel.Term -> Either Errors.DecodingError (PgModel.VertexWithAdjacentEdges v))
decodeVertexWithAdjacentEdges v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.decode.model.vertexWithAdjacentEdges")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL injection for the both variant of hydra.pg.model.Direction
directionBoth :: Typed.TypedTerm PgModel.Direction
directionBoth =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Direction"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "both"),
        CoreModel.fieldTerm = CoreModel.TermUnit}}))

-- | DSL name token for hydra.pg.model.Direction
directionDirection :: Typed.TypedName PgModel.Direction
directionDirection = Typed.TypedName (CoreModel.Name "hydra.pg.model.Direction")

-- | DSL injection for the in variant of hydra.pg.model.Direction
directionIn :: Typed.TypedTerm PgModel.Direction
directionIn =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Direction"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "in"),
        CoreModel.fieldTerm = CoreModel.TermUnit}}))

-- | DSL injection for the out variant of hydra.pg.model.Direction
directionOut :: Typed.TypedTerm PgModel.Direction
directionOut =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Direction"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "out"),
        CoreModel.fieldTerm = CoreModel.TermUnit}}))

-- | DSL injection for the undirected variant of hydra.pg.model.Direction
directionUndirected :: Typed.TypedTerm PgModel.Direction
directionUndirected =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Direction"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "undirected"),
        CoreModel.fieldTerm = CoreModel.TermUnit}}))

-- | DSL constructor for hydra.pg.model.Edge
edge :: Typed.TypedTerm PgModel.EdgeLabel -> Typed.TypedTerm v -> Typed.TypedTerm v -> Typed.TypedTerm v -> Typed.TypedTerm (M.Map PgModel.PropertyKey v) -> Typed.TypedTerm (PgModel.Edge v)
edge label id out in_ properties =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (Typed.unTypedTerm label)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (Typed.unTypedTerm id)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (Typed.unTypedTerm out)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (Typed.unTypedTerm in_)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (Typed.unTypedTerm properties)}]}))

-- | DSL name token for hydra.pg.model.Edge
edgeEdge :: Typed.TypedName (PgModel.Edge v)
edgeEdge = Typed.TypedName (CoreModel.Name "hydra.pg.model.Edge")

-- | DSL accessor for the id field of hydra.pg.model.Edge
edgeId :: Typed.TypedTerm (PgModel.Edge v) -> Typed.TypedTerm v
edgeId x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
        CoreModel.projectionFieldName = (CoreModel.Name "id")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the in field of hydra.pg.model.Edge
edgeIn :: Typed.TypedTerm (PgModel.Edge v) -> Typed.TypedTerm v
edgeIn x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
        CoreModel.projectionFieldName = (CoreModel.Name "in")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the label field of hydra.pg.model.Edge
edgeLabel :: Typed.TypedTerm (PgModel.Edge v) -> Typed.TypedTerm PgModel.EdgeLabel
edgeLabel x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
        CoreModel.projectionFieldName = (CoreModel.Name "label")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.pg.model.EdgeLabel wrapper
edgeLabel2 :: Typed.TypedTerm String -> Typed.TypedTerm PgModel.EdgeLabel
edgeLabel2 x =
    Typed.TypedTerm (CoreModel.TermWrap (CoreModel.WrappedTerm {
      CoreModel.wrappedTermTypeName = (CoreModel.Name "hydra.pg.model.EdgeLabel"),
      CoreModel.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.pg.model.EdgeLabel
edgeLabelEdgeLabel :: Typed.TypedName PgModel.EdgeLabel
edgeLabelEdgeLabel = Typed.TypedName (CoreModel.Name "hydra.pg.model.EdgeLabel")

-- | DSL accessor for the out field of hydra.pg.model.Edge
edgeOut :: Typed.TypedTerm (PgModel.Edge v) -> Typed.TypedTerm v
edgeOut x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
        CoreModel.projectionFieldName = (CoreModel.Name "out")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the properties field of hydra.pg.model.Edge
edgeProperties :: Typed.TypedTerm (PgModel.Edge v) -> Typed.TypedTerm (M.Map PgModel.PropertyKey v)
edgeProperties x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
        CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.pg.model.EdgeType
edgeType :: Typed.TypedTerm PgModel.EdgeLabel -> Typed.TypedTerm t -> Typed.TypedTerm PgModel.VertexLabel -> Typed.TypedTerm PgModel.VertexLabel -> Typed.TypedTerm [PgModel.PropertyType t] -> Typed.TypedTerm (PgModel.EdgeType t)
edgeType label id out in_ properties =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (Typed.unTypedTerm label)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (Typed.unTypedTerm id)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (Typed.unTypedTerm out)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (Typed.unTypedTerm in_)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (Typed.unTypedTerm properties)}]}))

-- | DSL name token for hydra.pg.model.EdgeType
edgeTypeEdgeType :: Typed.TypedName (PgModel.EdgeType t)
edgeTypeEdgeType = Typed.TypedName (CoreModel.Name "hydra.pg.model.EdgeType")

-- | DSL accessor for the id field of hydra.pg.model.EdgeType
edgeTypeId :: Typed.TypedTerm (PgModel.EdgeType t) -> Typed.TypedTerm t
edgeTypeId x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
        CoreModel.projectionFieldName = (CoreModel.Name "id")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the in field of hydra.pg.model.EdgeType
edgeTypeIn :: Typed.TypedTerm (PgModel.EdgeType t) -> Typed.TypedTerm PgModel.VertexLabel
edgeTypeIn x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
        CoreModel.projectionFieldName = (CoreModel.Name "in")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the label field of hydra.pg.model.EdgeType
edgeTypeLabel :: Typed.TypedTerm (PgModel.EdgeType t) -> Typed.TypedTerm PgModel.EdgeLabel
edgeTypeLabel x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
        CoreModel.projectionFieldName = (CoreModel.Name "label")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the out field of hydra.pg.model.EdgeType
edgeTypeOut :: Typed.TypedTerm (PgModel.EdgeType t) -> Typed.TypedTerm PgModel.VertexLabel
edgeTypeOut x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
        CoreModel.projectionFieldName = (CoreModel.Name "out")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the properties field of hydra.pg.model.EdgeType
edgeTypeProperties :: Typed.TypedTerm (PgModel.EdgeType t) -> Typed.TypedTerm [PgModel.PropertyType t]
edgeTypeProperties x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
        CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the id field of hydra.pg.model.EdgeType
edgeTypeWithId :: Typed.TypedTerm (PgModel.EdgeType t) -> Typed.TypedTerm t -> Typed.TypedTerm (PgModel.EdgeType t)
edgeTypeWithId original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "out")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "in")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the in field of hydra.pg.model.EdgeType
edgeTypeWithIn :: Typed.TypedTerm (PgModel.EdgeType t) -> Typed.TypedTerm PgModel.VertexLabel -> Typed.TypedTerm (PgModel.EdgeType t)
edgeTypeWithIn original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "out")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the label field of hydra.pg.model.EdgeType
edgeTypeWithLabel :: Typed.TypedTerm (PgModel.EdgeType t) -> Typed.TypedTerm PgModel.EdgeLabel -> Typed.TypedTerm (PgModel.EdgeType t)
edgeTypeWithLabel original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "out")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "in")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the out field of hydra.pg.model.EdgeType
edgeTypeWithOut :: Typed.TypedTerm (PgModel.EdgeType t) -> Typed.TypedTerm PgModel.VertexLabel -> Typed.TypedTerm (PgModel.EdgeType t)
edgeTypeWithOut original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "in")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the properties field of hydra.pg.model.EdgeType
edgeTypeWithProperties :: Typed.TypedTerm (PgModel.EdgeType t) -> Typed.TypedTerm [PgModel.PropertyType t] -> Typed.TypedTerm (PgModel.EdgeType t)
edgeTypeWithProperties original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "out")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.EdgeType"),
              CoreModel.projectionFieldName = (CoreModel.Name "in")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the id field of hydra.pg.model.Edge
edgeWithId :: Typed.TypedTerm (PgModel.Edge v) -> Typed.TypedTerm v -> Typed.TypedTerm (PgModel.Edge v)
edgeWithId original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "out")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "in")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the in field of hydra.pg.model.Edge
edgeWithIn :: Typed.TypedTerm (PgModel.Edge v) -> Typed.TypedTerm v -> Typed.TypedTerm (PgModel.Edge v)
edgeWithIn original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "out")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the label field of hydra.pg.model.Edge
edgeWithLabel :: Typed.TypedTerm (PgModel.Edge v) -> Typed.TypedTerm PgModel.EdgeLabel -> Typed.TypedTerm (PgModel.Edge v)
edgeWithLabel original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "out")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "in")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the out field of hydra.pg.model.Edge
edgeWithOut :: Typed.TypedTerm (PgModel.Edge v) -> Typed.TypedTerm v -> Typed.TypedTerm (PgModel.Edge v)
edgeWithOut original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "in")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the properties field of hydra.pg.model.Edge
edgeWithProperties :: Typed.TypedTerm (PgModel.Edge v) -> Typed.TypedTerm (M.Map PgModel.PropertyKey v) -> Typed.TypedTerm (PgModel.Edge v)
edgeWithProperties original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "out"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "out")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "in"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Edge"),
              CoreModel.projectionFieldName = (CoreModel.Name "in")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the edge variant of hydra.pg.model.Element
elementEdge :: Typed.TypedTerm (PgModel.Edge v) -> Typed.TypedTerm (PgModel.Element v)
elementEdge x =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Element"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "edge"),
        CoreModel.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.pg.model.Element
elementElement :: Typed.TypedName (PgModel.Element v)
elementElement = Typed.TypedName (CoreModel.Name "hydra.pg.model.Element")

-- | DSL injection for the edge variant of hydra.pg.model.ElementKind
elementKindEdge :: Typed.TypedTerm PgModel.ElementKind
elementKindEdge =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.ElementKind"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "edge"),
        CoreModel.fieldTerm = CoreModel.TermUnit}}))

-- | DSL name token for hydra.pg.model.ElementKind
elementKindElementKind :: Typed.TypedName PgModel.ElementKind
elementKindElementKind = Typed.TypedName (CoreModel.Name "hydra.pg.model.ElementKind")

-- | DSL injection for the vertex variant of hydra.pg.model.ElementKind
elementKindVertex :: Typed.TypedTerm PgModel.ElementKind
elementKindVertex =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.ElementKind"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "vertex"),
        CoreModel.fieldTerm = CoreModel.TermUnit}}))

-- | DSL constructor for hydra.pg.model.ElementTree
elementTree :: Typed.TypedTerm (PgModel.Element v) -> Typed.TypedTerm [PgModel.ElementTree v] -> Typed.TypedTerm (PgModel.ElementTree v)
elementTree self dependencies =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.ElementTree"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "self"),
          CoreModel.fieldTerm = (Typed.unTypedTerm self)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "dependencies"),
          CoreModel.fieldTerm = (Typed.unTypedTerm dependencies)}]}))

-- | DSL accessor for the dependencies field of hydra.pg.model.ElementTree
elementTreeDependencies :: Typed.TypedTerm (PgModel.ElementTree v) -> Typed.TypedTerm [PgModel.ElementTree v]
elementTreeDependencies x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.ElementTree"),
        CoreModel.projectionFieldName = (CoreModel.Name "dependencies")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.pg.model.ElementTree
elementTreeElementTree :: Typed.TypedName (PgModel.ElementTree v)
elementTreeElementTree = Typed.TypedName (CoreModel.Name "hydra.pg.model.ElementTree")

-- | DSL accessor for the self field of hydra.pg.model.ElementTree
elementTreeSelf :: Typed.TypedTerm (PgModel.ElementTree v) -> Typed.TypedTerm (PgModel.Element v)
elementTreeSelf x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.ElementTree"),
        CoreModel.projectionFieldName = (CoreModel.Name "self")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the dependencies field of hydra.pg.model.ElementTree
elementTreeWithDependencies :: Typed.TypedTerm (PgModel.ElementTree v) -> Typed.TypedTerm [PgModel.ElementTree v] -> Typed.TypedTerm (PgModel.ElementTree v)
elementTreeWithDependencies original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.ElementTree"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "self"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.ElementTree"),
              CoreModel.projectionFieldName = (CoreModel.Name "self")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "dependencies"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the self field of hydra.pg.model.ElementTree
elementTreeWithSelf :: Typed.TypedTerm (PgModel.ElementTree v) -> Typed.TypedTerm (PgModel.Element v) -> Typed.TypedTerm (PgModel.ElementTree v)
elementTreeWithSelf original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.ElementTree"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "self"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "dependencies"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.ElementTree"),
              CoreModel.projectionFieldName = (CoreModel.Name "dependencies")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the edge variant of hydra.pg.model.ElementType
elementTypeEdge :: Typed.TypedTerm (PgModel.EdgeType t) -> Typed.TypedTerm (PgModel.ElementType t)
elementTypeEdge x =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.ElementType"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "edge"),
        CoreModel.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.pg.model.ElementType
elementTypeElementType :: Typed.TypedName (PgModel.ElementType t)
elementTypeElementType = Typed.TypedName (CoreModel.Name "hydra.pg.model.ElementType")

-- | DSL constructor for hydra.pg.model.ElementTypeTree
elementTypeTree :: Typed.TypedTerm (PgModel.ElementType t) -> Typed.TypedTerm [PgModel.ElementTypeTree t] -> Typed.TypedTerm (PgModel.ElementTypeTree t)
elementTypeTree self dependencies =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.ElementTypeTree"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "self"),
          CoreModel.fieldTerm = (Typed.unTypedTerm self)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "dependencies"),
          CoreModel.fieldTerm = (Typed.unTypedTerm dependencies)}]}))

-- | DSL accessor for the dependencies field of hydra.pg.model.ElementTypeTree
elementTypeTreeDependencies :: Typed.TypedTerm (PgModel.ElementTypeTree t) -> Typed.TypedTerm [PgModel.ElementTypeTree t]
elementTypeTreeDependencies x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.ElementTypeTree"),
        CoreModel.projectionFieldName = (CoreModel.Name "dependencies")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.pg.model.ElementTypeTree
elementTypeTreeElementTypeTree :: Typed.TypedName (PgModel.ElementTypeTree t)
elementTypeTreeElementTypeTree = Typed.TypedName (CoreModel.Name "hydra.pg.model.ElementTypeTree")

-- | DSL accessor for the self field of hydra.pg.model.ElementTypeTree
elementTypeTreeSelf :: Typed.TypedTerm (PgModel.ElementTypeTree t) -> Typed.TypedTerm (PgModel.ElementType t)
elementTypeTreeSelf x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.ElementTypeTree"),
        CoreModel.projectionFieldName = (CoreModel.Name "self")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the dependencies field of hydra.pg.model.ElementTypeTree
elementTypeTreeWithDependencies :: Typed.TypedTerm (PgModel.ElementTypeTree t) -> Typed.TypedTerm [PgModel.ElementTypeTree t] -> Typed.TypedTerm (PgModel.ElementTypeTree t)
elementTypeTreeWithDependencies original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.ElementTypeTree"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "self"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.ElementTypeTree"),
              CoreModel.projectionFieldName = (CoreModel.Name "self")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "dependencies"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the self field of hydra.pg.model.ElementTypeTree
elementTypeTreeWithSelf :: Typed.TypedTerm (PgModel.ElementTypeTree t) -> Typed.TypedTerm (PgModel.ElementType t) -> Typed.TypedTerm (PgModel.ElementTypeTree t)
elementTypeTreeWithSelf original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.ElementTypeTree"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "self"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "dependencies"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.ElementTypeTree"),
              CoreModel.projectionFieldName = (CoreModel.Name "dependencies")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the vertex variant of hydra.pg.model.ElementType
elementTypeVertex :: Typed.TypedTerm (PgModel.VertexType t) -> Typed.TypedTerm (PgModel.ElementType t)
elementTypeVertex x =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.ElementType"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "vertex"),
        CoreModel.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the vertex variant of hydra.pg.model.Element
elementVertex :: Typed.TypedTerm (PgModel.Vertex v) -> Typed.TypedTerm (PgModel.Element v)
elementVertex x =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Element"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "vertex"),
        CoreModel.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL composition builder for the encoder of hydra.pg.model.AdjacentEdge
encodeAdjacentEdge :: Typed.TypedTerm (v -> CoreModel.Term) -> Typed.TypedTerm (PgModel.AdjacentEdge v -> CoreModel.Term)
encodeAdjacentEdge v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.adjacentEdge")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the encoder of hydra.pg.model.Edge
encodeEdge :: Typed.TypedTerm (v -> CoreModel.Term) -> Typed.TypedTerm (PgModel.Edge v -> CoreModel.Term)
encodeEdge v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.edge")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the encoder of hydra.pg.model.EdgeType
encodeEdgeType :: Typed.TypedTerm (t -> CoreModel.Term) -> Typed.TypedTerm (PgModel.EdgeType t -> CoreModel.Term)
encodeEdgeType t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.edgeType")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the encoder of hydra.pg.model.Element
encodeElement :: Typed.TypedTerm (v -> CoreModel.Term) -> Typed.TypedTerm (PgModel.Element v -> CoreModel.Term)
encodeElement v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.element")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the encoder of hydra.pg.model.ElementTree
encodeElementTree :: Typed.TypedTerm (v -> CoreModel.Term) -> Typed.TypedTerm (PgModel.ElementTree v -> CoreModel.Term)
encodeElementTree v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.elementTree")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the encoder of hydra.pg.model.ElementType
encodeElementType :: Typed.TypedTerm (t -> CoreModel.Term) -> Typed.TypedTerm (PgModel.ElementType t -> CoreModel.Term)
encodeElementType t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.elementType")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the encoder of hydra.pg.model.ElementTypeTree
encodeElementTypeTree :: Typed.TypedTerm (t -> CoreModel.Term) -> Typed.TypedTerm (PgModel.ElementTypeTree t -> CoreModel.Term)
encodeElementTypeTree t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.elementTypeTree")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the encoder of hydra.pg.model.Graph
encodeGraph :: Typed.TypedTerm (v -> CoreModel.Term) -> Typed.TypedTerm (PgModel.Graph v -> CoreModel.Term)
encodeGraph v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.graph")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the encoder of hydra.pg.model.GraphSchema
encodeGraphSchema :: Typed.TypedTerm (t -> CoreModel.Term) -> Typed.TypedTerm (PgModel.GraphSchema t -> CoreModel.Term)
encodeGraphSchema t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.graphSchema")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the encoder of hydra.pg.model.LazyGraph
encodeLazyGraph :: Typed.TypedTerm (v -> CoreModel.Term) -> Typed.TypedTerm (PgModel.LazyGraph v -> CoreModel.Term)
encodeLazyGraph v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.lazyGraph")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the encoder of hydra.pg.model.Property
encodeProperty :: Typed.TypedTerm (v -> CoreModel.Term) -> Typed.TypedTerm (PgModel.Property v -> CoreModel.Term)
encodeProperty v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.property")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the encoder of hydra.pg.model.PropertyType
encodePropertyType :: Typed.TypedTerm (t -> CoreModel.Term) -> Typed.TypedTerm (PgModel.PropertyType t -> CoreModel.Term)
encodePropertyType t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.propertyType")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the encoder of hydra.pg.model.Vertex
encodeVertex :: Typed.TypedTerm (v -> CoreModel.Term) -> Typed.TypedTerm (PgModel.Vertex v -> CoreModel.Term)
encodeVertex v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.vertex")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL composition builder for the encoder of hydra.pg.model.VertexType
encodeVertexType :: Typed.TypedTerm (t -> CoreModel.Term) -> Typed.TypedTerm (PgModel.VertexType t -> CoreModel.Term)
encodeVertexType t =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.vertexType")),
      CoreModel.applicationArgument = (Typed.unTypedTerm t)}))

-- | DSL composition builder for the encoder of hydra.pg.model.VertexWithAdjacentEdges
encodeVertexWithAdjacentEdges :: Typed.TypedTerm (v -> CoreModel.Term) -> Typed.TypedTerm (PgModel.VertexWithAdjacentEdges v -> CoreModel.Term)
encodeVertexWithAdjacentEdges v =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermVariable (CoreModel.Name "hydra.pg.encode.model.vertexWithAdjacentEdges")),
      CoreModel.applicationArgument = (Typed.unTypedTerm v)}))

-- | DSL constructor for hydra.pg.model.Graph
graph :: Typed.TypedTerm (M.Map v (PgModel.Vertex v)) -> Typed.TypedTerm (M.Map v (PgModel.Edge v)) -> Typed.TypedTerm (PgModel.Graph v)
graph vertices edges =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Graph"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = (Typed.unTypedTerm vertices)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = (Typed.unTypedTerm edges)}]}))

-- | DSL accessor for the edges field of hydra.pg.model.Graph
graphEdges :: Typed.TypedTerm (PgModel.Graph v) -> Typed.TypedTerm (M.Map v (PgModel.Edge v))
graphEdges x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Graph"),
        CoreModel.projectionFieldName = (CoreModel.Name "edges")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.pg.model.Graph
graphGraph :: Typed.TypedName (PgModel.Graph v)
graphGraph = Typed.TypedName (CoreModel.Name "hydra.pg.model.Graph")

-- | DSL constructor for hydra.pg.model.GraphSchema
graphSchema :: Typed.TypedTerm (M.Map PgModel.VertexLabel (PgModel.VertexType t)) -> Typed.TypedTerm (M.Map PgModel.EdgeLabel (PgModel.EdgeType t)) -> Typed.TypedTerm (PgModel.GraphSchema t)
graphSchema vertices edges =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.GraphSchema"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = (Typed.unTypedTerm vertices)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = (Typed.unTypedTerm edges)}]}))

-- | DSL accessor for the edges field of hydra.pg.model.GraphSchema
graphSchemaEdges :: Typed.TypedTerm (PgModel.GraphSchema t) -> Typed.TypedTerm (M.Map PgModel.EdgeLabel (PgModel.EdgeType t))
graphSchemaEdges x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.GraphSchema"),
        CoreModel.projectionFieldName = (CoreModel.Name "edges")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.pg.model.GraphSchema
graphSchemaGraphSchema :: Typed.TypedName (PgModel.GraphSchema t)
graphSchemaGraphSchema = Typed.TypedName (CoreModel.Name "hydra.pg.model.GraphSchema")

-- | DSL accessor for the vertices field of hydra.pg.model.GraphSchema
graphSchemaVertices :: Typed.TypedTerm (PgModel.GraphSchema t) -> Typed.TypedTerm (M.Map PgModel.VertexLabel (PgModel.VertexType t))
graphSchemaVertices x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.GraphSchema"),
        CoreModel.projectionFieldName = (CoreModel.Name "vertices")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the edges field of hydra.pg.model.GraphSchema
graphSchemaWithEdges :: Typed.TypedTerm (PgModel.GraphSchema t) -> Typed.TypedTerm (M.Map PgModel.EdgeLabel (PgModel.EdgeType t)) -> Typed.TypedTerm (PgModel.GraphSchema t)
graphSchemaWithEdges original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.GraphSchema"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.GraphSchema"),
              CoreModel.projectionFieldName = (CoreModel.Name "vertices")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the vertices field of hydra.pg.model.GraphSchema
graphSchemaWithVertices :: Typed.TypedTerm (PgModel.GraphSchema t) -> Typed.TypedTerm (M.Map PgModel.VertexLabel (PgModel.VertexType t)) -> Typed.TypedTerm (PgModel.GraphSchema t)
graphSchemaWithVertices original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.GraphSchema"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.GraphSchema"),
              CoreModel.projectionFieldName = (CoreModel.Name "edges")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the vertices field of hydra.pg.model.Graph
graphVertices :: Typed.TypedTerm (PgModel.Graph v) -> Typed.TypedTerm (M.Map v (PgModel.Vertex v))
graphVertices x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Graph"),
        CoreModel.projectionFieldName = (CoreModel.Name "vertices")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the edges field of hydra.pg.model.Graph
graphWithEdges :: Typed.TypedTerm (PgModel.Graph v) -> Typed.TypedTerm (M.Map v (PgModel.Edge v)) -> Typed.TypedTerm (PgModel.Graph v)
graphWithEdges original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Graph"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Graph"),
              CoreModel.projectionFieldName = (CoreModel.Name "vertices")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the vertices field of hydra.pg.model.Graph
graphWithVertices :: Typed.TypedTerm (PgModel.Graph v) -> Typed.TypedTerm (M.Map v (PgModel.Vertex v)) -> Typed.TypedTerm (PgModel.Graph v)
graphWithVertices original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Graph"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Graph"),
              CoreModel.projectionFieldName = (CoreModel.Name "edges")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the edge variant of hydra.pg.model.Label
labelEdge :: Typed.TypedTerm PgModel.EdgeLabel -> Typed.TypedTerm PgModel.Label
labelEdge x =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Label"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "edge"),
        CoreModel.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.pg.model.Label
labelLabel :: Typed.TypedName PgModel.Label
labelLabel = Typed.TypedName (CoreModel.Name "hydra.pg.model.Label")

-- | DSL injection for the vertex variant of hydra.pg.model.Label
labelVertex :: Typed.TypedTerm PgModel.VertexLabel -> Typed.TypedTerm PgModel.Label
labelVertex x =
    Typed.TypedTerm (CoreModel.TermInject (CoreModel.Injection {
      CoreModel.injectionTypeName = (CoreModel.Name "hydra.pg.model.Label"),
      CoreModel.injectionField = CoreModel.Field {
        CoreModel.fieldName = (CoreModel.Name "vertex"),
        CoreModel.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.pg.model.LazyGraph
lazyGraph :: Typed.TypedTerm [PgModel.Vertex v] -> Typed.TypedTerm [PgModel.Edge v] -> Typed.TypedTerm (PgModel.LazyGraph v)
lazyGraph vertices edges =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.LazyGraph"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = (Typed.unTypedTerm vertices)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = (Typed.unTypedTerm edges)}]}))

-- | DSL accessor for the edges field of hydra.pg.model.LazyGraph
lazyGraphEdges :: Typed.TypedTerm (PgModel.LazyGraph v) -> Typed.TypedTerm [PgModel.Edge v]
lazyGraphEdges x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.LazyGraph"),
        CoreModel.projectionFieldName = (CoreModel.Name "edges")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.pg.model.LazyGraph
lazyGraphLazyGraph :: Typed.TypedName (PgModel.LazyGraph v)
lazyGraphLazyGraph = Typed.TypedName (CoreModel.Name "hydra.pg.model.LazyGraph")

-- | DSL accessor for the vertices field of hydra.pg.model.LazyGraph
lazyGraphVertices :: Typed.TypedTerm (PgModel.LazyGraph v) -> Typed.TypedTerm [PgModel.Vertex v]
lazyGraphVertices x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.LazyGraph"),
        CoreModel.projectionFieldName = (CoreModel.Name "vertices")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the edges field of hydra.pg.model.LazyGraph
lazyGraphWithEdges :: Typed.TypedTerm (PgModel.LazyGraph v) -> Typed.TypedTerm [PgModel.Edge v] -> Typed.TypedTerm (PgModel.LazyGraph v)
lazyGraphWithEdges original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.LazyGraph"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.LazyGraph"),
              CoreModel.projectionFieldName = (CoreModel.Name "vertices")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the vertices field of hydra.pg.model.LazyGraph
lazyGraphWithVertices :: Typed.TypedTerm (PgModel.LazyGraph v) -> Typed.TypedTerm [PgModel.Vertex v] -> Typed.TypedTerm (PgModel.LazyGraph v)
lazyGraphWithVertices original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.LazyGraph"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertices"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "edges"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.LazyGraph"),
              CoreModel.projectionFieldName = (CoreModel.Name "edges")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.pg.model.Property
property :: Typed.TypedTerm PgModel.PropertyKey -> Typed.TypedTerm v -> Typed.TypedTerm (PgModel.Property v)
property key value =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Property"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "key"),
          CoreModel.fieldTerm = (Typed.unTypedTerm key)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "value"),
          CoreModel.fieldTerm = (Typed.unTypedTerm value)}]}))

-- | DSL accessor for the key field of hydra.pg.model.Property
propertyKey :: Typed.TypedTerm (PgModel.Property v) -> Typed.TypedTerm PgModel.PropertyKey
propertyKey x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Property"),
        CoreModel.projectionFieldName = (CoreModel.Name "key")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.pg.model.PropertyKey wrapper
propertyKey2 :: Typed.TypedTerm String -> Typed.TypedTerm PgModel.PropertyKey
propertyKey2 x =
    Typed.TypedTerm (CoreModel.TermWrap (CoreModel.WrappedTerm {
      CoreModel.wrappedTermTypeName = (CoreModel.Name "hydra.pg.model.PropertyKey"),
      CoreModel.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.pg.model.PropertyKey
propertyKeyPropertyKey :: Typed.TypedName PgModel.PropertyKey
propertyKeyPropertyKey = Typed.TypedName (CoreModel.Name "hydra.pg.model.PropertyKey")

-- | DSL name token for hydra.pg.model.Property
propertyProperty :: Typed.TypedName (PgModel.Property v)
propertyProperty = Typed.TypedName (CoreModel.Name "hydra.pg.model.Property")

-- | DSL constructor for hydra.pg.model.PropertyType
propertyType :: Typed.TypedTerm PgModel.PropertyKey -> Typed.TypedTerm t -> Typed.TypedTerm Bool -> Typed.TypedTerm (PgModel.PropertyType t)
propertyType key value required =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "key"),
          CoreModel.fieldTerm = (Typed.unTypedTerm key)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "value"),
          CoreModel.fieldTerm = (Typed.unTypedTerm value)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "required"),
          CoreModel.fieldTerm = (Typed.unTypedTerm required)}]}))

-- | DSL accessor for the key field of hydra.pg.model.PropertyType
propertyTypeKey :: Typed.TypedTerm (PgModel.PropertyType t) -> Typed.TypedTerm PgModel.PropertyKey
propertyTypeKey x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
        CoreModel.projectionFieldName = (CoreModel.Name "key")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.pg.model.PropertyType
propertyTypePropertyType :: Typed.TypedName (PgModel.PropertyType t)
propertyTypePropertyType = Typed.TypedName (CoreModel.Name "hydra.pg.model.PropertyType")

-- | DSL accessor for the required field of hydra.pg.model.PropertyType
propertyTypeRequired :: Typed.TypedTerm (PgModel.PropertyType t) -> Typed.TypedTerm Bool
propertyTypeRequired x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
        CoreModel.projectionFieldName = (CoreModel.Name "required")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the value field of hydra.pg.model.PropertyType
propertyTypeValue :: Typed.TypedTerm (PgModel.PropertyType t) -> Typed.TypedTerm t
propertyTypeValue x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
        CoreModel.projectionFieldName = (CoreModel.Name "value")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the key field of hydra.pg.model.PropertyType
propertyTypeWithKey :: Typed.TypedTerm (PgModel.PropertyType t) -> Typed.TypedTerm PgModel.PropertyKey -> Typed.TypedTerm (PgModel.PropertyType t)
propertyTypeWithKey original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "key"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "value"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
              CoreModel.projectionFieldName = (CoreModel.Name "value")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "required"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
              CoreModel.projectionFieldName = (CoreModel.Name "required")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the required field of hydra.pg.model.PropertyType
propertyTypeWithRequired :: Typed.TypedTerm (PgModel.PropertyType t) -> Typed.TypedTerm Bool -> Typed.TypedTerm (PgModel.PropertyType t)
propertyTypeWithRequired original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "key"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
              CoreModel.projectionFieldName = (CoreModel.Name "key")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "value"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
              CoreModel.projectionFieldName = (CoreModel.Name "value")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "required"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the value field of hydra.pg.model.PropertyType
propertyTypeWithValue :: Typed.TypedTerm (PgModel.PropertyType t) -> Typed.TypedTerm t -> Typed.TypedTerm (PgModel.PropertyType t)
propertyTypeWithValue original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "key"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
              CoreModel.projectionFieldName = (CoreModel.Name "key")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "value"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "required"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.PropertyType"),
              CoreModel.projectionFieldName = (CoreModel.Name "required")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the value field of hydra.pg.model.Property
propertyValue :: Typed.TypedTerm (PgModel.Property v) -> Typed.TypedTerm v
propertyValue x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Property"),
        CoreModel.projectionFieldName = (CoreModel.Name "value")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the key field of hydra.pg.model.Property
propertyWithKey :: Typed.TypedTerm (PgModel.Property v) -> Typed.TypedTerm PgModel.PropertyKey -> Typed.TypedTerm (PgModel.Property v)
propertyWithKey original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Property"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "key"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "value"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Property"),
              CoreModel.projectionFieldName = (CoreModel.Name "value")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.pg.model.Property
propertyWithValue :: Typed.TypedTerm (PgModel.Property v) -> Typed.TypedTerm v -> Typed.TypedTerm (PgModel.Property v)
propertyWithValue original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Property"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "key"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Property"),
              CoreModel.projectionFieldName = (CoreModel.Name "key")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "value"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL accessor for the body of hydra.pg.model.EdgeLabel
unEdgeLabel :: Typed.TypedTerm PgModel.EdgeLabel -> Typed.TypedTerm String
unEdgeLabel x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermUnwrap (CoreModel.Name "hydra.pg.model.EdgeLabel")),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.pg.model.PropertyKey
unPropertyKey :: Typed.TypedTerm PgModel.PropertyKey -> Typed.TypedTerm String
unPropertyKey x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermUnwrap (CoreModel.Name "hydra.pg.model.PropertyKey")),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.pg.model.VertexLabel
unVertexLabel :: Typed.TypedTerm PgModel.VertexLabel -> Typed.TypedTerm String
unVertexLabel x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermUnwrap (CoreModel.Name "hydra.pg.model.VertexLabel")),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.pg.model.Vertex
vertex :: Typed.TypedTerm PgModel.VertexLabel -> Typed.TypedTerm v -> Typed.TypedTerm (M.Map PgModel.PropertyKey v) -> Typed.TypedTerm (PgModel.Vertex v)
vertex label id properties =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (Typed.unTypedTerm label)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (Typed.unTypedTerm id)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (Typed.unTypedTerm properties)}]}))

-- | DSL accessor for the id field of hydra.pg.model.Vertex
vertexId :: Typed.TypedTerm (PgModel.Vertex v) -> Typed.TypedTerm v
vertexId x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
        CoreModel.projectionFieldName = (CoreModel.Name "id")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the label field of hydra.pg.model.Vertex
vertexLabel :: Typed.TypedTerm (PgModel.Vertex v) -> Typed.TypedTerm PgModel.VertexLabel
vertexLabel x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
        CoreModel.projectionFieldName = (CoreModel.Name "label")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.pg.model.VertexLabel wrapper
vertexLabel2 :: Typed.TypedTerm String -> Typed.TypedTerm PgModel.VertexLabel
vertexLabel2 x =
    Typed.TypedTerm (CoreModel.TermWrap (CoreModel.WrappedTerm {
      CoreModel.wrappedTermTypeName = (CoreModel.Name "hydra.pg.model.VertexLabel"),
      CoreModel.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.pg.model.VertexLabel
vertexLabelVertexLabel :: Typed.TypedName PgModel.VertexLabel
vertexLabelVertexLabel = Typed.TypedName (CoreModel.Name "hydra.pg.model.VertexLabel")

-- | DSL accessor for the properties field of hydra.pg.model.Vertex
vertexProperties :: Typed.TypedTerm (PgModel.Vertex v) -> Typed.TypedTerm (M.Map PgModel.PropertyKey v)
vertexProperties x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
        CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.pg.model.VertexType
vertexType :: Typed.TypedTerm PgModel.VertexLabel -> Typed.TypedTerm t -> Typed.TypedTerm [PgModel.PropertyType t] -> Typed.TypedTerm (PgModel.VertexType t)
vertexType label id properties =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (Typed.unTypedTerm label)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (Typed.unTypedTerm id)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (Typed.unTypedTerm properties)}]}))

-- | DSL accessor for the id field of hydra.pg.model.VertexType
vertexTypeId :: Typed.TypedTerm (PgModel.VertexType t) -> Typed.TypedTerm t
vertexTypeId x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
        CoreModel.projectionFieldName = (CoreModel.Name "id")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the label field of hydra.pg.model.VertexType
vertexTypeLabel :: Typed.TypedTerm (PgModel.VertexType t) -> Typed.TypedTerm PgModel.VertexLabel
vertexTypeLabel x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
        CoreModel.projectionFieldName = (CoreModel.Name "label")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the properties field of hydra.pg.model.VertexType
vertexTypeProperties :: Typed.TypedTerm (PgModel.VertexType t) -> Typed.TypedTerm [PgModel.PropertyType t]
vertexTypeProperties x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
        CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.pg.model.VertexType
vertexTypeVertexType :: Typed.TypedName (PgModel.VertexType t)
vertexTypeVertexType = Typed.TypedName (CoreModel.Name "hydra.pg.model.VertexType")

-- | DSL updater for the id field of hydra.pg.model.VertexType
vertexTypeWithId :: Typed.TypedTerm (PgModel.VertexType t) -> Typed.TypedTerm t -> Typed.TypedTerm (PgModel.VertexType t)
vertexTypeWithId original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the label field of hydra.pg.model.VertexType
vertexTypeWithLabel :: Typed.TypedTerm (PgModel.VertexType t) -> Typed.TypedTerm PgModel.VertexLabel -> Typed.TypedTerm (PgModel.VertexType t)
vertexTypeWithLabel original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the properties field of hydra.pg.model.VertexType
vertexTypeWithProperties :: Typed.TypedTerm (PgModel.VertexType t) -> Typed.TypedTerm [PgModel.PropertyType t] -> Typed.TypedTerm (PgModel.VertexType t)
vertexTypeWithProperties original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexType"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL name token for hydra.pg.model.Vertex
vertexVertex :: Typed.TypedName (PgModel.Vertex v)
vertexVertex = Typed.TypedName (CoreModel.Name "hydra.pg.model.Vertex")

-- | DSL constructor for hydra.pg.model.VertexWithAdjacentEdges
vertexWithAdjacentEdges :: Typed.TypedTerm (PgModel.Vertex v) -> Typed.TypedTerm [PgModel.AdjacentEdge v] -> Typed.TypedTerm [PgModel.AdjacentEdge v] -> Typed.TypedTerm (PgModel.VertexWithAdjacentEdges v)
vertexWithAdjacentEdges vertex ins outs =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (Typed.unTypedTerm vertex)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "ins"),
          CoreModel.fieldTerm = (Typed.unTypedTerm ins)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "outs"),
          CoreModel.fieldTerm = (Typed.unTypedTerm outs)}]}))

-- | DSL accessor for the ins field of hydra.pg.model.VertexWithAdjacentEdges
vertexWithAdjacentEdgesIns :: Typed.TypedTerm (PgModel.VertexWithAdjacentEdges v) -> Typed.TypedTerm [PgModel.AdjacentEdge v]
vertexWithAdjacentEdgesIns x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
        CoreModel.projectionFieldName = (CoreModel.Name "ins")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the outs field of hydra.pg.model.VertexWithAdjacentEdges
vertexWithAdjacentEdgesOuts :: Typed.TypedTerm (PgModel.VertexWithAdjacentEdges v) -> Typed.TypedTerm [PgModel.AdjacentEdge v]
vertexWithAdjacentEdgesOuts x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
        CoreModel.projectionFieldName = (CoreModel.Name "outs")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the vertex field of hydra.pg.model.VertexWithAdjacentEdges
vertexWithAdjacentEdgesVertex :: Typed.TypedTerm (PgModel.VertexWithAdjacentEdges v) -> Typed.TypedTerm (PgModel.Vertex v)
vertexWithAdjacentEdgesVertex x =
    Typed.TypedTerm (CoreModel.TermApplication (CoreModel.Application {
      CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
        CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
        CoreModel.projectionFieldName = (CoreModel.Name "vertex")})),
      CoreModel.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.pg.model.VertexWithAdjacentEdges
vertexWithAdjacentEdgesVertexWithAdjacentEdges :: Typed.TypedName (PgModel.VertexWithAdjacentEdges v)
vertexWithAdjacentEdgesVertexWithAdjacentEdges = Typed.TypedName (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges")

-- | DSL updater for the ins field of hydra.pg.model.VertexWithAdjacentEdges
vertexWithAdjacentEdgesWithIns :: Typed.TypedTerm (PgModel.VertexWithAdjacentEdges v) -> Typed.TypedTerm [PgModel.AdjacentEdge v] -> Typed.TypedTerm (PgModel.VertexWithAdjacentEdges v)
vertexWithAdjacentEdgesWithIns original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
              CoreModel.projectionFieldName = (CoreModel.Name "vertex")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "ins"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "outs"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
              CoreModel.projectionFieldName = (CoreModel.Name "outs")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the outs field of hydra.pg.model.VertexWithAdjacentEdges
vertexWithAdjacentEdgesWithOuts :: Typed.TypedTerm (PgModel.VertexWithAdjacentEdges v) -> Typed.TypedTerm [PgModel.AdjacentEdge v] -> Typed.TypedTerm (PgModel.VertexWithAdjacentEdges v)
vertexWithAdjacentEdgesWithOuts original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
              CoreModel.projectionFieldName = (CoreModel.Name "vertex")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "ins"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
              CoreModel.projectionFieldName = (CoreModel.Name "ins")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "outs"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the vertex field of hydra.pg.model.VertexWithAdjacentEdges
vertexWithAdjacentEdgesWithVertex :: Typed.TypedTerm (PgModel.VertexWithAdjacentEdges v) -> Typed.TypedTerm (PgModel.Vertex v) -> Typed.TypedTerm (PgModel.VertexWithAdjacentEdges v)
vertexWithAdjacentEdgesWithVertex original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "vertex"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "ins"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
              CoreModel.projectionFieldName = (CoreModel.Name "ins")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "outs"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.VertexWithAdjacentEdges"),
              CoreModel.projectionFieldName = (CoreModel.Name "outs")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.pg.model.Vertex
vertexWithId :: Typed.TypedTerm (PgModel.Vertex v) -> Typed.TypedTerm v -> Typed.TypedTerm (PgModel.Vertex v)
vertexWithId original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the label field of hydra.pg.model.Vertex
vertexWithLabel :: Typed.TypedTerm (PgModel.Vertex v) -> Typed.TypedTerm PgModel.VertexLabel -> Typed.TypedTerm (PgModel.Vertex v)
vertexWithLabel original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
              CoreModel.projectionFieldName = (CoreModel.Name "properties")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the properties field of hydra.pg.model.Vertex
vertexWithProperties :: Typed.TypedTerm (PgModel.Vertex v) -> Typed.TypedTerm (M.Map PgModel.PropertyKey v) -> Typed.TypedTerm (PgModel.Vertex v)
vertexWithProperties original newVal =
    Typed.TypedTerm (CoreModel.TermRecord (CoreModel.Record {
      CoreModel.recordTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
      CoreModel.recordFields = [
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "label"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
              CoreModel.projectionFieldName = (CoreModel.Name "label")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "id"),
          CoreModel.fieldTerm = (CoreModel.TermApplication (CoreModel.Application {
            CoreModel.applicationFunction = (CoreModel.TermProject (CoreModel.Projection {
              CoreModel.projectionTypeName = (CoreModel.Name "hydra.pg.model.Vertex"),
              CoreModel.projectionFieldName = (CoreModel.Name "id")})),
            CoreModel.applicationArgument = (Typed.unTypedTerm original)}))},
        CoreModel.Field {
          CoreModel.fieldName = (CoreModel.Name "properties"),
          CoreModel.fieldTerm = (Typed.unTypedTerm newVal)}]}))