packages feed

hydra-kernel-0.18.0: src/main/haskell/Hydra/Core/Dsl/Markdown.hs

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

-- | DSL functions for hydra.core.markdown

module Hydra.Core.Dsl.Markdown where

import qualified Hydra.Core.Decode.Markdown as DecodeMarkdown
import qualified Hydra.Core.Encode.Markdown as EncodeMarkdown
import qualified Hydra.Core.Markdown as Markdown
import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void

-- | DSL name token for hydra.core.markdown.Block
blockBlock :: Typed.TypedName Markdown.Block
blockBlock = Typed.TypedName (Model.Name "hydra.core.markdown.Block")

-- | DSL injection for the codeBlock variant of hydra.core.markdown.Block
blockCodeBlock :: Typed.TypedTerm Markdown.CodeBlock -> Typed.TypedTerm Markdown.Block
blockCodeBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "codeBlock"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the list variant of hydra.core.markdown.Block
blockList :: Typed.TypedTerm Markdown.List -> Typed.TypedTerm Markdown.Block
blockList x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "list"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the paragraph variant of hydra.core.markdown.Block
blockParagraph :: Typed.TypedTerm Markdown.Paragraph -> Typed.TypedTerm Markdown.Block
blockParagraph x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "paragraph"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the raw variant of hydra.core.markdown.Block
blockRaw :: Typed.TypedTerm String -> Typed.TypedTerm Markdown.Block
blockRaw x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "raw"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the section variant of hydra.core.markdown.Block
blockSection :: Typed.TypedTerm Markdown.Section -> Typed.TypedTerm Markdown.Block
blockSection x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "section"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the table variant of hydra.core.markdown.Block
blockTable :: Typed.TypedTerm Markdown.Table -> Typed.TypedTerm Markdown.Block
blockTable x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "table"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.core.markdown.CodeBlock
codeBlock :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm String -> Typed.TypedTerm Markdown.CodeBlock
codeBlock language content =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.CodeBlock"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "language"),
          Model.fieldTerm = (Typed.unTypedTerm language)},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm content)}]}))

-- | DSL name token for hydra.core.markdown.CodeBlock
codeBlockCodeBlock :: Typed.TypedName Markdown.CodeBlock
codeBlockCodeBlock = Typed.TypedName (Model.Name "hydra.core.markdown.CodeBlock")

-- | DSL accessor for the content field of hydra.core.markdown.CodeBlock
codeBlockContent :: Typed.TypedTerm Markdown.CodeBlock -> Typed.TypedTerm String
codeBlockContent x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.CodeBlock"),
        Model.projectionFieldName = (Model.Name "content")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the language field of hydra.core.markdown.CodeBlock
codeBlockLanguage :: Typed.TypedTerm Markdown.CodeBlock -> Typed.TypedTerm (Maybe String)
codeBlockLanguage x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.CodeBlock"),
        Model.projectionFieldName = (Model.Name "language")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the content field of hydra.core.markdown.CodeBlock
codeBlockWithContent :: Typed.TypedTerm Markdown.CodeBlock -> Typed.TypedTerm String -> Typed.TypedTerm Markdown.CodeBlock
codeBlockWithContent original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.CodeBlock"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "language"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.CodeBlock"),
              Model.projectionFieldName = (Model.Name "language")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the language field of hydra.core.markdown.CodeBlock
codeBlockWithLanguage :: Typed.TypedTerm Markdown.CodeBlock -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Markdown.CodeBlock
codeBlockWithLanguage original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.CodeBlock"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "language"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.CodeBlock"),
              Model.projectionFieldName = (Model.Name "content")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.markdown.Document
document :: Typed.TypedTerm String -> Typed.TypedTerm [Markdown.Block] -> Typed.TypedTerm Markdown.Document
document title content =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Document"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Typed.unTypedTerm title)},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm content)}]}))

-- | DSL accessor for the content field of hydra.core.markdown.Document
documentContent :: Typed.TypedTerm Markdown.Document -> Typed.TypedTerm [Markdown.Block]
documentContent x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Document"),
        Model.projectionFieldName = (Model.Name "content")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.markdown.Document
documentDocument :: Typed.TypedName Markdown.Document
documentDocument = Typed.TypedName (Model.Name "hydra.core.markdown.Document")

-- | DSL accessor for the title field of hydra.core.markdown.Document
documentTitle :: Typed.TypedTerm Markdown.Document -> Typed.TypedTerm String
documentTitle x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Document"),
        Model.projectionFieldName = (Model.Name "title")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the content field of hydra.core.markdown.Document
documentWithContent :: Typed.TypedTerm Markdown.Document -> Typed.TypedTerm [Markdown.Block] -> Typed.TypedTerm Markdown.Document
documentWithContent original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Document"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Document"),
              Model.projectionFieldName = (Model.Name "title")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the title field of hydra.core.markdown.Document
documentWithTitle :: Typed.TypedTerm Markdown.Document -> Typed.TypedTerm String -> Typed.TypedTerm Markdown.Document
documentWithTitle original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Document"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Document"),
              Model.projectionFieldName = (Model.Name "content")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.markdown.Heading
heading :: Typed.TypedTerm Int -> Typed.TypedTerm [Markdown.Inline] -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Markdown.Heading
heading level content anchor =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Heading"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "level"),
          Model.fieldTerm = (Typed.unTypedTerm level)},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm content)},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = (Typed.unTypedTerm anchor)}]}))

-- | DSL accessor for the anchor field of hydra.core.markdown.Heading
headingAnchor :: Typed.TypedTerm Markdown.Heading -> Typed.TypedTerm (Maybe String)
headingAnchor x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Heading"),
        Model.projectionFieldName = (Model.Name "anchor")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the content field of hydra.core.markdown.Heading
headingContent :: Typed.TypedTerm Markdown.Heading -> Typed.TypedTerm [Markdown.Inline]
headingContent x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Heading"),
        Model.projectionFieldName = (Model.Name "content")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.markdown.Heading
headingHeading :: Typed.TypedName Markdown.Heading
headingHeading = Typed.TypedName (Model.Name "hydra.core.markdown.Heading")

-- | DSL accessor for the level field of hydra.core.markdown.Heading
headingLevel :: Typed.TypedTerm Markdown.Heading -> Typed.TypedTerm Int
headingLevel x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Heading"),
        Model.projectionFieldName = (Model.Name "level")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the anchor field of hydra.core.markdown.Heading
headingWithAnchor :: Typed.TypedTerm Markdown.Heading -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Markdown.Heading
headingWithAnchor original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Heading"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "level"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Heading"),
              Model.projectionFieldName = (Model.Name "level")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Heading"),
              Model.projectionFieldName = (Model.Name "content")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the content field of hydra.core.markdown.Heading
headingWithContent :: Typed.TypedTerm Markdown.Heading -> Typed.TypedTerm [Markdown.Inline] -> Typed.TypedTerm Markdown.Heading
headingWithContent original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Heading"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "level"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Heading"),
              Model.projectionFieldName = (Model.Name "level")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Heading"),
              Model.projectionFieldName = (Model.Name "anchor")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the level field of hydra.core.markdown.Heading
headingWithLevel :: Typed.TypedTerm Markdown.Heading -> Typed.TypedTerm Int -> Typed.TypedTerm Markdown.Heading
headingWithLevel original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Heading"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "level"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Heading"),
              Model.projectionFieldName = (Model.Name "content")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Heading"),
              Model.projectionFieldName = (Model.Name "anchor")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the code variant of hydra.core.markdown.Inline
inlineCode :: Typed.TypedTerm String -> Typed.TypedTerm Markdown.Inline
inlineCode x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.markdown.Inline"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "code"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the emphasis variant of hydra.core.markdown.Inline
inlineEmphasis :: Typed.TypedTerm [Markdown.Inline] -> Typed.TypedTerm Markdown.Inline
inlineEmphasis x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.markdown.Inline"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "emphasis"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.core.markdown.Inline
inlineInline :: Typed.TypedName Markdown.Inline
inlineInline = Typed.TypedName (Model.Name "hydra.core.markdown.Inline")

-- | DSL injection for the link variant of hydra.core.markdown.Inline
inlineLink :: Typed.TypedTerm Markdown.Link -> Typed.TypedTerm Markdown.Inline
inlineLink x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.markdown.Inline"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "link"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the strong variant of hydra.core.markdown.Inline
inlineStrong :: Typed.TypedTerm [Markdown.Inline] -> Typed.TypedTerm Markdown.Inline
inlineStrong x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.markdown.Inline"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "strong"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the text variant of hydra.core.markdown.Inline
inlineText :: Typed.TypedTerm String -> Typed.TypedTerm Markdown.Inline
inlineText x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.markdown.Inline"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "text"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.core.markdown.Link
link :: Typed.TypedTerm [Markdown.Inline] -> Typed.TypedTerm String -> Typed.TypedTerm Markdown.Link
link text target =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Link"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "text"),
          Model.fieldTerm = (Typed.unTypedTerm text)},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm target)}]}))

-- | DSL name token for hydra.core.markdown.Link
linkLink :: Typed.TypedName Markdown.Link
linkLink = Typed.TypedName (Model.Name "hydra.core.markdown.Link")

-- | DSL accessor for the target field of hydra.core.markdown.Link
linkTarget :: Typed.TypedTerm Markdown.Link -> Typed.TypedTerm String
linkTarget x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Link"),
        Model.projectionFieldName = (Model.Name "target")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the text field of hydra.core.markdown.Link
linkText :: Typed.TypedTerm Markdown.Link -> Typed.TypedTerm [Markdown.Inline]
linkText x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Link"),
        Model.projectionFieldName = (Model.Name "text")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the target field of hydra.core.markdown.Link
linkWithTarget :: Typed.TypedTerm Markdown.Link -> Typed.TypedTerm String -> Typed.TypedTerm Markdown.Link
linkWithTarget original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Link"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "text"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Link"),
              Model.projectionFieldName = (Model.Name "text")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the text field of hydra.core.markdown.Link
linkWithText :: Typed.TypedTerm Markdown.Link -> Typed.TypedTerm [Markdown.Inline] -> Typed.TypedTerm Markdown.Link
linkWithText original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Link"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "text"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Link"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.markdown.List
list :: Typed.TypedTerm Bool -> Typed.TypedTerm [Markdown.ListItem] -> Typed.TypedTerm Markdown.List
list ordered items =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.List"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "ordered"),
          Model.fieldTerm = (Typed.unTypedTerm ordered)},
        Model.Field {
          Model.fieldName = (Model.Name "items"),
          Model.fieldTerm = (Typed.unTypedTerm items)}]}))

-- | DSL constructor for the hydra.core.markdown.ListItem wrapper
listItem :: Typed.TypedTerm [Markdown.Block] -> Typed.TypedTerm Markdown.ListItem
listItem x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.core.markdown.ListItem"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.markdown.ListItem
listItemListItem :: Typed.TypedName Markdown.ListItem
listItemListItem = Typed.TypedName (Model.Name "hydra.core.markdown.ListItem")

-- | DSL accessor for the items field of hydra.core.markdown.List
listItems :: Typed.TypedTerm Markdown.List -> Typed.TypedTerm [Markdown.ListItem]
listItems x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.List"),
        Model.projectionFieldName = (Model.Name "items")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.markdown.List
listList :: Typed.TypedName Markdown.List
listList = Typed.TypedName (Model.Name "hydra.core.markdown.List")

-- | DSL accessor for the ordered field of hydra.core.markdown.List
listOrdered :: Typed.TypedTerm Markdown.List -> Typed.TypedTerm Bool
listOrdered x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.List"),
        Model.projectionFieldName = (Model.Name "ordered")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the items field of hydra.core.markdown.List
listWithItems :: Typed.TypedTerm Markdown.List -> Typed.TypedTerm [Markdown.ListItem] -> Typed.TypedTerm Markdown.List
listWithItems original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.List"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "ordered"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.List"),
              Model.projectionFieldName = (Model.Name "ordered")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "items"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the ordered field of hydra.core.markdown.List
listWithOrdered :: Typed.TypedTerm Markdown.List -> Typed.TypedTerm Bool -> Typed.TypedTerm Markdown.List
listWithOrdered original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.List"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "ordered"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "items"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.List"),
              Model.projectionFieldName = (Model.Name "items")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.markdown.Paragraph
paragraph :: Typed.TypedTerm [Markdown.Inline] -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Markdown.Paragraph
paragraph content anchor =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Paragraph"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm content)},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = (Typed.unTypedTerm anchor)}]}))

-- | DSL accessor for the anchor field of hydra.core.markdown.Paragraph
paragraphAnchor :: Typed.TypedTerm Markdown.Paragraph -> Typed.TypedTerm (Maybe String)
paragraphAnchor x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Paragraph"),
        Model.projectionFieldName = (Model.Name "anchor")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the content field of hydra.core.markdown.Paragraph
paragraphContent :: Typed.TypedTerm Markdown.Paragraph -> Typed.TypedTerm [Markdown.Inline]
paragraphContent x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Paragraph"),
        Model.projectionFieldName = (Model.Name "content")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.markdown.Paragraph
paragraphParagraph :: Typed.TypedName Markdown.Paragraph
paragraphParagraph = Typed.TypedName (Model.Name "hydra.core.markdown.Paragraph")

-- | DSL updater for the anchor field of hydra.core.markdown.Paragraph
paragraphWithAnchor :: Typed.TypedTerm Markdown.Paragraph -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Markdown.Paragraph
paragraphWithAnchor original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Paragraph"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Paragraph"),
              Model.projectionFieldName = (Model.Name "content")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the content field of hydra.core.markdown.Paragraph
paragraphWithContent :: Typed.TypedTerm Markdown.Paragraph -> Typed.TypedTerm [Markdown.Inline] -> Typed.TypedTerm Markdown.Paragraph
paragraphWithContent original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Paragraph"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Paragraph"),
              Model.projectionFieldName = (Model.Name "anchor")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.markdown.Section
section :: Typed.TypedTerm Markdown.Heading -> Typed.TypedTerm [Markdown.Block] -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Markdown.Section
section heading content anchor =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Section"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "heading"),
          Model.fieldTerm = (Typed.unTypedTerm heading)},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm content)},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = (Typed.unTypedTerm anchor)}]}))

-- | DSL accessor for the anchor field of hydra.core.markdown.Section
sectionAnchor :: Typed.TypedTerm Markdown.Section -> Typed.TypedTerm (Maybe String)
sectionAnchor x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Section"),
        Model.projectionFieldName = (Model.Name "anchor")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the content field of hydra.core.markdown.Section
sectionContent :: Typed.TypedTerm Markdown.Section -> Typed.TypedTerm [Markdown.Block]
sectionContent x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Section"),
        Model.projectionFieldName = (Model.Name "content")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the heading field of hydra.core.markdown.Section
sectionHeading :: Typed.TypedTerm Markdown.Section -> Typed.TypedTerm Markdown.Heading
sectionHeading x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Section"),
        Model.projectionFieldName = (Model.Name "heading")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.markdown.Section
sectionSection :: Typed.TypedName Markdown.Section
sectionSection = Typed.TypedName (Model.Name "hydra.core.markdown.Section")

-- | DSL updater for the anchor field of hydra.core.markdown.Section
sectionWithAnchor :: Typed.TypedTerm Markdown.Section -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Markdown.Section
sectionWithAnchor original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Section"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "heading"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Section"),
              Model.projectionFieldName = (Model.Name "heading")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Section"),
              Model.projectionFieldName = (Model.Name "content")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the content field of hydra.core.markdown.Section
sectionWithContent :: Typed.TypedTerm Markdown.Section -> Typed.TypedTerm [Markdown.Block] -> Typed.TypedTerm Markdown.Section
sectionWithContent original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Section"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "heading"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Section"),
              Model.projectionFieldName = (Model.Name "heading")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Section"),
              Model.projectionFieldName = (Model.Name "anchor")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the heading field of hydra.core.markdown.Section
sectionWithHeading :: Typed.TypedTerm Markdown.Section -> Typed.TypedTerm Markdown.Heading -> Typed.TypedTerm Markdown.Section
sectionWithHeading original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Section"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "heading"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Section"),
              Model.projectionFieldName = (Model.Name "content")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Section"),
              Model.projectionFieldName = (Model.Name "anchor")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.markdown.Table
table :: Typed.TypedTerm Markdown.TableRow -> Typed.TypedTerm [Markdown.TableRow] -> Typed.TypedTerm Markdown.Table
table header rows =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Table"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm header)},
        Model.Field {
          Model.fieldName = (Model.Name "rows"),
          Model.fieldTerm = (Typed.unTypedTerm rows)}]}))

-- | DSL constructor for the hydra.core.markdown.TableCell wrapper
tableCell :: Typed.TypedTerm [Markdown.Inline] -> Typed.TypedTerm Markdown.TableCell
tableCell x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.core.markdown.TableCell"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.markdown.TableCell
tableCellTableCell :: Typed.TypedName Markdown.TableCell
tableCellTableCell = Typed.TypedName (Model.Name "hydra.core.markdown.TableCell")

-- | DSL accessor for the header field of hydra.core.markdown.Table
tableHeader :: Typed.TypedTerm Markdown.Table -> Typed.TypedTerm Markdown.TableRow
tableHeader x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Table"),
        Model.projectionFieldName = (Model.Name "header")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.core.markdown.TableRow wrapper
tableRow :: Typed.TypedTerm [Markdown.TableCell] -> Typed.TypedTerm Markdown.TableRow
tableRow x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.core.markdown.TableRow"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.markdown.TableRow
tableRowTableRow :: Typed.TypedName Markdown.TableRow
tableRowTableRow = Typed.TypedName (Model.Name "hydra.core.markdown.TableRow")

-- | DSL accessor for the rows field of hydra.core.markdown.Table
tableRows :: Typed.TypedTerm Markdown.Table -> Typed.TypedTerm [Markdown.TableRow]
tableRows x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.markdown.Table"),
        Model.projectionFieldName = (Model.Name "rows")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.markdown.Table
tableTable :: Typed.TypedName Markdown.Table
tableTable = Typed.TypedName (Model.Name "hydra.core.markdown.Table")

-- | DSL updater for the header field of hydra.core.markdown.Table
tableWithHeader :: Typed.TypedTerm Markdown.Table -> Typed.TypedTerm Markdown.TableRow -> Typed.TypedTerm Markdown.Table
tableWithHeader original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Table"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "rows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Table"),
              Model.projectionFieldName = (Model.Name "rows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the rows field of hydra.core.markdown.Table
tableWithRows :: Typed.TypedTerm Markdown.Table -> Typed.TypedTerm [Markdown.TableRow] -> Typed.TypedTerm Markdown.Table
tableWithRows original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Table"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.markdown.Table"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rows"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL accessor for the body of hydra.core.markdown.ListItem
unListItem :: Typed.TypedTerm Markdown.ListItem -> Typed.TypedTerm [Markdown.Block]
unListItem x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.core.markdown.ListItem")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.core.markdown.TableCell
unTableCell :: Typed.TypedTerm Markdown.TableCell -> Typed.TypedTerm [Markdown.Inline]
unTableCell x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.core.markdown.TableCell")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.core.markdown.TableRow
unTableRow :: Typed.TypedTerm Markdown.TableRow -> Typed.TypedTerm [Markdown.TableCell]
unTableRow x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.core.markdown.TableRow")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))