hydra-ext-0.18.0: src/main/haskell/Hydra/Ext/Dsl/Json/Schema/Model.hs

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

-- | DSL functions for hydra.ext.json.schema.model

module Hydra.Ext.Dsl.Json.Schema.Model where

import qualified Hydra.Core.Json.Model as JsonModel
import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Ext.Json.Schema.Model as SchemaModel
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 name token for hydra.ext.json.schema.model.AdditionalItems
additionalItemsAdditionalItems :: Typed.TypedName SchemaModel.AdditionalItems
additionalItemsAdditionalItems = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.AdditionalItems")

-- | DSL injection for the any variant of hydra.ext.json.schema.model.AdditionalItems
additionalItemsAny :: Typed.TypedTerm Bool -> Typed.TypedTerm SchemaModel.AdditionalItems
additionalItemsAny x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.AdditionalItems"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "any"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the schema variant of hydra.ext.json.schema.model.AdditionalItems
additionalItemsSchema :: Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.AdditionalItems
additionalItemsSchema x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.AdditionalItems"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "schema"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the additionalItems variant of hydra.ext.json.schema.model.ArrayRestriction
arrayRestrictionAdditionalItems :: Typed.TypedTerm SchemaModel.AdditionalItems -> Typed.TypedTerm SchemaModel.ArrayRestriction
arrayRestrictionAdditionalItems x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ArrayRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "additionalItems"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.json.schema.model.ArrayRestriction
arrayRestrictionArrayRestriction :: Typed.TypedName SchemaModel.ArrayRestriction
arrayRestrictionArrayRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.ArrayRestriction")

-- | DSL injection for the items variant of hydra.ext.json.schema.model.ArrayRestriction
arrayRestrictionItems :: Typed.TypedTerm SchemaModel.Items -> Typed.TypedTerm SchemaModel.ArrayRestriction
arrayRestrictionItems x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ArrayRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "items"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the maxItems variant of hydra.ext.json.schema.model.ArrayRestriction
arrayRestrictionMaxItems :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.ArrayRestriction
arrayRestrictionMaxItems x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ArrayRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "maxItems"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the minItems variant of hydra.ext.json.schema.model.ArrayRestriction
arrayRestrictionMinItems :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.ArrayRestriction
arrayRestrictionMinItems x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ArrayRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minItems"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the uniqueItems variant of hydra.ext.json.schema.model.ArrayRestriction
arrayRestrictionUniqueItems :: Typed.TypedTerm Bool -> Typed.TypedTerm SchemaModel.ArrayRestriction
arrayRestrictionUniqueItems x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ArrayRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uniqueItems"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.json.schema.model.Document
document :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe (M.Map SchemaModel.Keyword SchemaModel.Schema)) -> Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.Document
document id definitions root =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "definitions"),
          Model.fieldTerm = (Typed.unTypedTerm definitions)},
        Model.Field {
          Model.fieldName = (Model.Name "root"),
          Model.fieldTerm = (Typed.unTypedTerm root)}]}))

-- | DSL accessor for the definitions field of hydra.ext.json.schema.model.Document
documentDefinitions :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm (Maybe (M.Map SchemaModel.Keyword SchemaModel.Schema))
documentDefinitions x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
        Model.projectionFieldName = (Model.Name "definitions")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.json.schema.model.Document
documentDocument :: Typed.TypedName SchemaModel.Document
documentDocument = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Document")

-- | DSL accessor for the id field of hydra.ext.json.schema.model.Document
documentId :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm (Maybe String)
documentId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the root field of hydra.ext.json.schema.model.Document
documentRoot :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm SchemaModel.Schema
documentRoot x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
        Model.projectionFieldName = (Model.Name "root")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the definitions field of hydra.ext.json.schema.model.Document
documentWithDefinitions :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm (Maybe (M.Map SchemaModel.Keyword SchemaModel.Schema)) -> Typed.TypedTerm SchemaModel.Document
documentWithDefinitions original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitions"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "root"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
              Model.projectionFieldName = (Model.Name "root")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.json.schema.model.Document
documentWithId :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm SchemaModel.Document
documentWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "definitions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
              Model.projectionFieldName = (Model.Name "definitions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "root"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
              Model.projectionFieldName = (Model.Name "root")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the root field of hydra.ext.json.schema.model.Document
documentWithRoot :: Typed.TypedTerm SchemaModel.Document -> Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.Document
documentWithRoot original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Document"),
              Model.projectionFieldName = (Model.Name "definitions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "root"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL name token for hydra.ext.json.schema.model.Items
itemsItems :: Typed.TypedName SchemaModel.Items
itemsItems = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Items")

-- | DSL injection for the sameItems variant of hydra.ext.json.schema.model.Items
itemsSameItems :: Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.Items
itemsSameItems x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Items"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sameItems"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the varItems variant of hydra.ext.json.schema.model.Items
itemsVarItems :: Typed.TypedTerm [SchemaModel.Schema] -> Typed.TypedTerm SchemaModel.Items
itemsVarItems x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Items"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "varItems"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.json.schema.model.Keyword wrapper
keyword :: Typed.TypedTerm String -> Typed.TypedTerm SchemaModel.Keyword
keyword x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.json.schema.model.Keyword"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.json.schema.model.Keyword
keywordKeyword :: Typed.TypedName SchemaModel.Keyword
keywordKeyword = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Keyword")

-- | DSL constructor for hydra.ext.json.schema.model.Limit
limit :: Typed.TypedTerm Int -> Typed.TypedTerm Bool -> Typed.TypedTerm SchemaModel.Limit
limit value exclusive =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)},
        Model.Field {
          Model.fieldName = (Model.Name "exclusive"),
          Model.fieldTerm = (Typed.unTypedTerm exclusive)}]}))

-- | DSL accessor for the exclusive field of hydra.ext.json.schema.model.Limit
limitExclusive :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm Bool
limitExclusive x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"),
        Model.projectionFieldName = (Model.Name "exclusive")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.json.schema.model.Limit
limitLimit :: Typed.TypedName SchemaModel.Limit
limitLimit = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Limit")

-- | DSL accessor for the value field of hydra.ext.json.schema.model.Limit
limitValue :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm Int
limitValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the exclusive field of hydra.ext.json.schema.model.Limit
limitWithExclusive :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm Bool -> Typed.TypedTerm SchemaModel.Limit
limitWithExclusive original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "exclusive"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the value field of hydra.ext.json.schema.model.Limit
limitWithValue :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.Limit
limitWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "exclusive"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.json.schema.model.Limit"),
              Model.projectionFieldName = (Model.Name "exclusive")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the allOf variant of hydra.ext.json.schema.model.MultipleRestriction
multipleRestrictionAllOf :: Typed.TypedTerm [SchemaModel.Schema] -> Typed.TypedTerm SchemaModel.MultipleRestriction
multipleRestrictionAllOf x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.MultipleRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "allOf"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the anyOf variant of hydra.ext.json.schema.model.MultipleRestriction
multipleRestrictionAnyOf :: Typed.TypedTerm [SchemaModel.Schema] -> Typed.TypedTerm SchemaModel.MultipleRestriction
multipleRestrictionAnyOf x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.MultipleRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "anyOf"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the enum variant of hydra.ext.json.schema.model.MultipleRestriction
multipleRestrictionEnum :: Typed.TypedTerm [JsonModel.Value] -> Typed.TypedTerm SchemaModel.MultipleRestriction
multipleRestrictionEnum x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.MultipleRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "enum"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.json.schema.model.MultipleRestriction
multipleRestrictionMultipleRestriction :: Typed.TypedName SchemaModel.MultipleRestriction
multipleRestrictionMultipleRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.MultipleRestriction")

-- | DSL injection for the not variant of hydra.ext.json.schema.model.MultipleRestriction
multipleRestrictionNot :: Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.MultipleRestriction
multipleRestrictionNot x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.MultipleRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "not"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the oneOf variant of hydra.ext.json.schema.model.MultipleRestriction
multipleRestrictionOneOf :: Typed.TypedTerm [SchemaModel.Schema] -> Typed.TypedTerm SchemaModel.MultipleRestriction
multipleRestrictionOneOf x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.MultipleRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "oneOf"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the maximum variant of hydra.ext.json.schema.model.NumericRestriction
numericRestrictionMaximum :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm SchemaModel.NumericRestriction
numericRestrictionMaximum x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.NumericRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "maximum"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the minimum variant of hydra.ext.json.schema.model.NumericRestriction
numericRestrictionMinimum :: Typed.TypedTerm SchemaModel.Limit -> Typed.TypedTerm SchemaModel.NumericRestriction
numericRestrictionMinimum x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.NumericRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minimum"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the multipleOf variant of hydra.ext.json.schema.model.NumericRestriction
numericRestrictionMultipleOf :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.NumericRestriction
numericRestrictionMultipleOf x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.NumericRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "multipleOf"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.json.schema.model.NumericRestriction
numericRestrictionNumericRestriction :: Typed.TypedName SchemaModel.NumericRestriction
numericRestrictionNumericRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.NumericRestriction")

-- | DSL injection for the additionalProperties variant of hydra.ext.json.schema.model.ObjectRestriction
objectRestrictionAdditionalProperties :: Typed.TypedTerm SchemaModel.AdditionalItems -> Typed.TypedTerm SchemaModel.ObjectRestriction
objectRestrictionAdditionalProperties x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "additionalProperties"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the dependencies variant of hydra.ext.json.schema.model.ObjectRestriction
objectRestrictionDependencies :: Typed.TypedTerm (M.Map SchemaModel.Keyword SchemaModel.SchemaOrArray) -> Typed.TypedTerm SchemaModel.ObjectRestriction
objectRestrictionDependencies x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "dependencies"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the maxProperties variant of hydra.ext.json.schema.model.ObjectRestriction
objectRestrictionMaxProperties :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.ObjectRestriction
objectRestrictionMaxProperties x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "maxProperties"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the minProperties variant of hydra.ext.json.schema.model.ObjectRestriction
objectRestrictionMinProperties :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.ObjectRestriction
objectRestrictionMinProperties x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minProperties"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.json.schema.model.ObjectRestriction
objectRestrictionObjectRestriction :: Typed.TypedName SchemaModel.ObjectRestriction
objectRestrictionObjectRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.ObjectRestriction")

-- | DSL injection for the patternProperties variant of hydra.ext.json.schema.model.ObjectRestriction
objectRestrictionPatternProperties :: Typed.TypedTerm (M.Map SchemaModel.RegularExpression SchemaModel.Schema) -> Typed.TypedTerm SchemaModel.ObjectRestriction
objectRestrictionPatternProperties x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "patternProperties"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the properties variant of hydra.ext.json.schema.model.ObjectRestriction
objectRestrictionProperties :: Typed.TypedTerm (M.Map SchemaModel.Keyword SchemaModel.Schema) -> Typed.TypedTerm SchemaModel.ObjectRestriction
objectRestrictionProperties x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "properties"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the required variant of hydra.ext.json.schema.model.ObjectRestriction
objectRestrictionRequired :: Typed.TypedTerm [SchemaModel.Keyword] -> Typed.TypedTerm SchemaModel.ObjectRestriction
objectRestrictionRequired x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.ObjectRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "required"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.json.schema.model.RegularExpression wrapper
regularExpression :: Typed.TypedTerm String -> Typed.TypedTerm SchemaModel.RegularExpression
regularExpression x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.json.schema.model.RegularExpression"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.json.schema.model.RegularExpression
regularExpressionRegularExpression :: Typed.TypedName SchemaModel.RegularExpression
regularExpressionRegularExpression = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.RegularExpression")

-- | DSL injection for the array variant of hydra.ext.json.schema.model.Restriction
restrictionArray :: Typed.TypedTerm SchemaModel.ArrayRestriction -> Typed.TypedTerm SchemaModel.Restriction
restrictionArray x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "array"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the description variant of hydra.ext.json.schema.model.Restriction
restrictionDescription :: Typed.TypedTerm String -> Typed.TypedTerm SchemaModel.Restriction
restrictionDescription x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "description"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the multiple variant of hydra.ext.json.schema.model.Restriction
restrictionMultiple :: Typed.TypedTerm SchemaModel.MultipleRestriction -> Typed.TypedTerm SchemaModel.Restriction
restrictionMultiple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "multiple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the number variant of hydra.ext.json.schema.model.Restriction
restrictionNumber :: Typed.TypedTerm SchemaModel.NumericRestriction -> Typed.TypedTerm SchemaModel.Restriction
restrictionNumber x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "number"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the object variant of hydra.ext.json.schema.model.Restriction
restrictionObject :: Typed.TypedTerm SchemaModel.ObjectRestriction -> Typed.TypedTerm SchemaModel.Restriction
restrictionObject x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "object"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the reference variant of hydra.ext.json.schema.model.Restriction
restrictionReference :: Typed.TypedTerm SchemaModel.SchemaReference -> Typed.TypedTerm SchemaModel.Restriction
restrictionReference x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "reference"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.json.schema.model.Restriction
restrictionRestriction :: Typed.TypedName SchemaModel.Restriction
restrictionRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Restriction")

-- | DSL injection for the string variant of hydra.ext.json.schema.model.Restriction
restrictionString :: Typed.TypedTerm SchemaModel.StringRestriction -> Typed.TypedTerm SchemaModel.Restriction
restrictionString x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the title variant of hydra.ext.json.schema.model.Restriction
restrictionTitle :: Typed.TypedTerm String -> Typed.TypedTerm SchemaModel.Restriction
restrictionTitle x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "title"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the type variant of hydra.ext.json.schema.model.Restriction
restrictionType :: Typed.TypedTerm SchemaModel.Type -> Typed.TypedTerm SchemaModel.Restriction
restrictionType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Restriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "type"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.json.schema.model.Schema wrapper
schema :: Typed.TypedTerm [SchemaModel.Restriction] -> Typed.TypedTerm SchemaModel.Schema
schema x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.json.schema.model.Schema"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL injection for the array variant of hydra.ext.json.schema.model.SchemaOrArray
schemaOrArrayArray :: Typed.TypedTerm [SchemaModel.Keyword] -> Typed.TypedTerm SchemaModel.SchemaOrArray
schemaOrArrayArray x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.SchemaOrArray"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "array"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the schema variant of hydra.ext.json.schema.model.SchemaOrArray
schemaOrArraySchema :: Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm SchemaModel.SchemaOrArray
schemaOrArraySchema x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.SchemaOrArray"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "schema"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.json.schema.model.SchemaOrArray
schemaOrArraySchemaOrArray :: Typed.TypedName SchemaModel.SchemaOrArray
schemaOrArraySchemaOrArray = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.SchemaOrArray")

-- | DSL constructor for the hydra.ext.json.schema.model.SchemaReference wrapper
schemaReference :: Typed.TypedTerm String -> Typed.TypedTerm SchemaModel.SchemaReference
schemaReference x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.json.schema.model.SchemaReference"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.json.schema.model.SchemaReference
schemaReferenceSchemaReference :: Typed.TypedName SchemaModel.SchemaReference
schemaReferenceSchemaReference = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.SchemaReference")

-- | DSL name token for hydra.ext.json.schema.model.Schema
schemaSchema :: Typed.TypedName SchemaModel.Schema
schemaSchema = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Schema")

-- | DSL injection for the maxLength variant of hydra.ext.json.schema.model.StringRestriction
stringRestrictionMaxLength :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.StringRestriction
stringRestrictionMaxLength x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.StringRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "maxLength"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the minLength variant of hydra.ext.json.schema.model.StringRestriction
stringRestrictionMinLength :: Typed.TypedTerm Int -> Typed.TypedTerm SchemaModel.StringRestriction
stringRestrictionMinLength x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.StringRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minLength"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the pattern variant of hydra.ext.json.schema.model.StringRestriction
stringRestrictionPattern :: Typed.TypedTerm SchemaModel.RegularExpression -> Typed.TypedTerm SchemaModel.StringRestriction
stringRestrictionPattern x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.StringRestriction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pattern"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.json.schema.model.StringRestriction
stringRestrictionStringRestriction :: Typed.TypedName SchemaModel.StringRestriction
stringRestrictionStringRestriction = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.StringRestriction")

-- | DSL injection for the multiple variant of hydra.ext.json.schema.model.Type
typeMultiple :: Typed.TypedTerm [SchemaModel.TypeName] -> Typed.TypedTerm SchemaModel.Type
typeMultiple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "multiple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the array variant of hydra.ext.json.schema.model.TypeName
typeNameArray :: Typed.TypedTerm SchemaModel.TypeName
typeNameArray =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "array"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the boolean variant of hydra.ext.json.schema.model.TypeName
typeNameBoolean :: Typed.TypedTerm SchemaModel.TypeName
typeNameBoolean =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "boolean"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the integer variant of hydra.ext.json.schema.model.TypeName
typeNameInteger :: Typed.TypedTerm SchemaModel.TypeName
typeNameInteger =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "integer"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the null variant of hydra.ext.json.schema.model.TypeName
typeNameNull :: Typed.TypedTerm SchemaModel.TypeName
typeNameNull =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "null"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the number variant of hydra.ext.json.schema.model.TypeName
typeNameNumber :: Typed.TypedTerm SchemaModel.TypeName
typeNameNumber =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "number"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the object variant of hydra.ext.json.schema.model.TypeName
typeNameObject :: Typed.TypedTerm SchemaModel.TypeName
typeNameObject =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "object"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the string variant of hydra.ext.json.schema.model.TypeName
typeNameString :: Typed.TypedTerm SchemaModel.TypeName
typeNameString =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.TypeName"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.json.schema.model.TypeName
typeNameTypeName :: Typed.TypedName SchemaModel.TypeName
typeNameTypeName = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.TypeName")

-- | DSL injection for the single variant of hydra.ext.json.schema.model.Type
typeSingle :: Typed.TypedTerm SchemaModel.TypeName -> Typed.TypedTerm SchemaModel.Type
typeSingle x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.json.schema.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "single"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.json.schema.model.Type
typeType :: Typed.TypedName SchemaModel.Type
typeType = Typed.TypedName (Model.Name "hydra.ext.json.schema.model.Type")

-- | DSL accessor for the body of hydra.ext.json.schema.model.Keyword
unKeyword :: Typed.TypedTerm SchemaModel.Keyword -> Typed.TypedTerm String
unKeyword x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.json.schema.model.Keyword")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.json.schema.model.RegularExpression
unRegularExpression :: Typed.TypedTerm SchemaModel.RegularExpression -> Typed.TypedTerm String
unRegularExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.json.schema.model.RegularExpression")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.json.schema.model.Schema
unSchema :: Typed.TypedTerm SchemaModel.Schema -> Typed.TypedTerm [SchemaModel.Restriction]
unSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.json.schema.model.Schema")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.json.schema.model.SchemaReference
unSchemaReference :: Typed.TypedTerm SchemaModel.SchemaReference -> Typed.TypedTerm String
unSchemaReference x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.json.schema.model.SchemaReference")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))