packages feed

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

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

-- | DSL functions for hydra.ext.geojson.model

module Hydra.Ext.Dsl.Geojson.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.Geojson.Model as GeojsonModel
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 the hydra.ext.geojson.model.BoundingBox wrapper
boundingBox :: Typed.TypedTerm [GeojsonModel.CoordinateRange] -> Typed.TypedTerm GeojsonModel.BoundingBox
boundingBox x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.geojson.model.BoundingBox"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.geojson.model.BoundingBox
boundingBoxBoundingBox :: Typed.TypedName GeojsonModel.BoundingBox
boundingBoxBoundingBox = Typed.TypedName (Model.Name "hydra.ext.geojson.model.BoundingBox")

-- | DSL constructor for hydra.ext.geojson.model.CoordinateRange
coordinateRange :: Typed.TypedTerm Double -> Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.CoordinateRange
coordinateRange min max =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "min"),
          Model.fieldTerm = (Typed.unTypedTerm min)},
        Model.Field {
          Model.fieldName = (Model.Name "max"),
          Model.fieldTerm = (Typed.unTypedTerm max)}]}))

-- | DSL name token for hydra.ext.geojson.model.CoordinateRange
coordinateRangeCoordinateRange :: Typed.TypedName GeojsonModel.CoordinateRange
coordinateRangeCoordinateRange = Typed.TypedName (Model.Name "hydra.ext.geojson.model.CoordinateRange")

-- | DSL accessor for the max field of hydra.ext.geojson.model.CoordinateRange
coordinateRangeMax :: Typed.TypedTerm GeojsonModel.CoordinateRange -> Typed.TypedTerm Double
coordinateRangeMax x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"),
        Model.projectionFieldName = (Model.Name "max")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the min field of hydra.ext.geojson.model.CoordinateRange
coordinateRangeMin :: Typed.TypedTerm GeojsonModel.CoordinateRange -> Typed.TypedTerm Double
coordinateRangeMin x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"),
        Model.projectionFieldName = (Model.Name "min")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the max field of hydra.ext.geojson.model.CoordinateRange
coordinateRangeWithMax :: Typed.TypedTerm GeojsonModel.CoordinateRange -> Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.CoordinateRange
coordinateRangeWithMax original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "min"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"),
              Model.projectionFieldName = (Model.Name "min")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "max"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the min field of hydra.ext.geojson.model.CoordinateRange
coordinateRangeWithMin :: Typed.TypedTerm GeojsonModel.CoordinateRange -> Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.CoordinateRange
coordinateRangeWithMin original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "min"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "max"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.CoordinateRange"),
              Model.projectionFieldName = (Model.Name "max")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.geojson.model.Feature
feature :: Typed.TypedTerm (Maybe GeojsonModel.Geometry) -> Typed.TypedTerm (Maybe (M.Map String JsonModel.Value)) -> Typed.TypedTerm (Maybe GeojsonModel.Id) -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Feature
feature geometry properties id bbox =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "geometry"),
          Model.fieldTerm = (Typed.unTypedTerm geometry)},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Typed.unTypedTerm properties)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm bbox)}]}))

-- | DSL accessor for the bbox field of hydra.ext.geojson.model.Feature
featureBbox :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox)
featureBbox x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
        Model.projectionFieldName = (Model.Name "bbox")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.geojson.model.FeatureCollection
featureCollection :: Typed.TypedTerm [GeojsonModel.Feature] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.FeatureCollection
featureCollection features bbox =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "features"),
          Model.fieldTerm = (Typed.unTypedTerm features)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm bbox)}]}))

-- | DSL accessor for the bbox field of hydra.ext.geojson.model.FeatureCollection
featureCollectionBbox :: Typed.TypedTerm GeojsonModel.FeatureCollection -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox)
featureCollectionBbox x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"),
        Model.projectionFieldName = (Model.Name "bbox")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.geojson.model.FeatureCollection
featureCollectionFeatureCollection :: Typed.TypedName GeojsonModel.FeatureCollection
featureCollectionFeatureCollection = Typed.TypedName (Model.Name "hydra.ext.geojson.model.FeatureCollection")

-- | DSL accessor for the features field of hydra.ext.geojson.model.FeatureCollection
featureCollectionFeatures :: Typed.TypedTerm GeojsonModel.FeatureCollection -> Typed.TypedTerm [GeojsonModel.Feature]
featureCollectionFeatures x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"),
        Model.projectionFieldName = (Model.Name "features")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the bbox field of hydra.ext.geojson.model.FeatureCollection
featureCollectionWithBbox :: Typed.TypedTerm GeojsonModel.FeatureCollection -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.FeatureCollection
featureCollectionWithBbox original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "features"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"),
              Model.projectionFieldName = (Model.Name "features")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the features field of hydra.ext.geojson.model.FeatureCollection
featureCollectionWithFeatures :: Typed.TypedTerm GeojsonModel.FeatureCollection -> Typed.TypedTerm [GeojsonModel.Feature] -> Typed.TypedTerm GeojsonModel.FeatureCollection
featureCollectionWithFeatures original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "features"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.FeatureCollection"),
              Model.projectionFieldName = (Model.Name "bbox")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.geojson.model.Feature
featureFeature :: Typed.TypedName GeojsonModel.Feature
featureFeature = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Feature")

-- | DSL accessor for the geometry field of hydra.ext.geojson.model.Feature
featureGeometry :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.Geometry)
featureGeometry x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
        Model.projectionFieldName = (Model.Name "geometry")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.geojson.model.Feature
featureId :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.Id)
featureId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the properties field of hydra.ext.geojson.model.Feature
featureProperties :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe (M.Map String JsonModel.Value))
featureProperties x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
        Model.projectionFieldName = (Model.Name "properties")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the bbox field of hydra.ext.geojson.model.Feature
featureWithBbox :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Feature
featureWithBbox original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "geometry"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "geometry")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the geometry field of hydra.ext.geojson.model.Feature
featureWithGeometry :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.Geometry) -> Typed.TypedTerm GeojsonModel.Feature
featureWithGeometry original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "geometry"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "bbox")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.geojson.model.Feature
featureWithId :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe GeojsonModel.Id) -> Typed.TypedTerm GeojsonModel.Feature
featureWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "geometry"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "geometry")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "bbox")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the properties field of hydra.ext.geojson.model.Feature
featureWithProperties :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm (Maybe (M.Map String JsonModel.Value)) -> Typed.TypedTerm GeojsonModel.Feature
featureWithProperties original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "geometry"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "geometry")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        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.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Feature"),
              Model.projectionFieldName = (Model.Name "bbox")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.geojson.model.GeometryCollection
geometryCollection :: Typed.TypedTerm [GeojsonModel.Geometry] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.GeometryCollection
geometryCollection geometries bbox =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "geometries"),
          Model.fieldTerm = (Typed.unTypedTerm geometries)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm bbox)}]}))

-- | DSL accessor for the bbox field of hydra.ext.geojson.model.GeometryCollection
geometryCollectionBbox :: Typed.TypedTerm GeojsonModel.GeometryCollection -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox)
geometryCollectionBbox x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"),
        Model.projectionFieldName = (Model.Name "bbox")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the geometries field of hydra.ext.geojson.model.GeometryCollection
geometryCollectionGeometries :: Typed.TypedTerm GeojsonModel.GeometryCollection -> Typed.TypedTerm [GeojsonModel.Geometry]
geometryCollectionGeometries x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"),
        Model.projectionFieldName = (Model.Name "geometries")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.geojson.model.GeometryCollection
geometryCollectionGeometryCollection :: Typed.TypedName GeojsonModel.GeometryCollection
geometryCollectionGeometryCollection = Typed.TypedName (Model.Name "hydra.ext.geojson.model.GeometryCollection")

-- | DSL updater for the bbox field of hydra.ext.geojson.model.GeometryCollection
geometryCollectionWithBbox :: Typed.TypedTerm GeojsonModel.GeometryCollection -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.GeometryCollection
geometryCollectionWithBbox original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "geometries"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"),
              Model.projectionFieldName = (Model.Name "geometries")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the geometries field of hydra.ext.geojson.model.GeometryCollection
geometryCollectionWithGeometries :: Typed.TypedTerm GeojsonModel.GeometryCollection -> Typed.TypedTerm [GeojsonModel.Geometry] -> Typed.TypedTerm GeojsonModel.GeometryCollection
geometryCollectionWithGeometries original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "geometries"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.GeometryCollection"),
              Model.projectionFieldName = (Model.Name "bbox")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.geojson.model.Geometry
geometryGeometry :: Typed.TypedName GeojsonModel.Geometry
geometryGeometry = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Geometry")

-- | DSL injection for the geometryCollection variant of hydra.ext.geojson.model.Geometry
geometryGeometryCollection :: Typed.TypedTerm GeojsonModel.GeometryCollection -> Typed.TypedTerm GeojsonModel.Geometry
geometryGeometryCollection x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "geometryCollection"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the lineString variant of hydra.ext.geojson.model.Geometry
geometryLineString :: Typed.TypedTerm GeojsonModel.LineString -> Typed.TypedTerm GeojsonModel.Geometry
geometryLineString x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lineString"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the multiLineString variant of hydra.ext.geojson.model.Geometry
geometryMultiLineString :: Typed.TypedTerm GeojsonModel.MultiLineString -> Typed.TypedTerm GeojsonModel.Geometry
geometryMultiLineString x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "multiLineString"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the multiPoint variant of hydra.ext.geojson.model.Geometry
geometryMultiPoint :: Typed.TypedTerm GeojsonModel.MultiPoint -> Typed.TypedTerm GeojsonModel.Geometry
geometryMultiPoint x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "multiPoint"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the multiPolygon variant of hydra.ext.geojson.model.Geometry
geometryMultiPolygon :: Typed.TypedTerm GeojsonModel.MultiPolygon -> Typed.TypedTerm GeojsonModel.Geometry
geometryMultiPolygon x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "multiPolygon"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the point variant of hydra.ext.geojson.model.Geometry
geometryPoint :: Typed.TypedTerm GeojsonModel.Point -> Typed.TypedTerm GeojsonModel.Geometry
geometryPoint x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "point"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the polygon variant of hydra.ext.geojson.model.Geometry
geometryPolygon :: Typed.TypedTerm GeojsonModel.Polygon -> Typed.TypedTerm GeojsonModel.Geometry
geometryPolygon x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Geometry"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "polygon"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.geojson.model.Id
idId :: Typed.TypedName GeojsonModel.Id
idId = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Id")

-- | DSL injection for the number variant of hydra.ext.geojson.model.Id
idNumber :: Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.Id
idNumber x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Id"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "number"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the string variant of hydra.ext.geojson.model.Id
idString :: Typed.TypedTerm String -> Typed.TypedTerm GeojsonModel.Id
idString x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Id"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.geojson.model.LineString
lineString :: Typed.TypedTerm [GeojsonModel.Position] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.LineString
lineString coordinates bbox =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.LineString"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm coordinates)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm bbox)}]}))

-- | DSL accessor for the bbox field of hydra.ext.geojson.model.LineString
lineStringBbox :: Typed.TypedTerm GeojsonModel.LineString -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox)
lineStringBbox x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.LineString"),
        Model.projectionFieldName = (Model.Name "bbox")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.LineString
lineStringCoordinates :: Typed.TypedTerm GeojsonModel.LineString -> Typed.TypedTerm [GeojsonModel.Position]
lineStringCoordinates x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.LineString"),
        Model.projectionFieldName = (Model.Name "coordinates")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.geojson.model.LineString
lineStringLineString :: Typed.TypedName GeojsonModel.LineString
lineStringLineString = Typed.TypedName (Model.Name "hydra.ext.geojson.model.LineString")

-- | DSL updater for the bbox field of hydra.ext.geojson.model.LineString
lineStringWithBbox :: Typed.TypedTerm GeojsonModel.LineString -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.LineString
lineStringWithBbox original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.LineString"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.LineString"),
              Model.projectionFieldName = (Model.Name "coordinates")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the coordinates field of hydra.ext.geojson.model.LineString
lineStringWithCoordinates :: Typed.TypedTerm GeojsonModel.LineString -> Typed.TypedTerm [GeojsonModel.Position] -> Typed.TypedTerm GeojsonModel.LineString
lineStringWithCoordinates original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.LineString"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.LineString"),
              Model.projectionFieldName = (Model.Name "bbox")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.geojson.model.MultiLineString
multiLineString :: Typed.TypedTerm [GeojsonModel.LineString] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiLineString
multiLineString coordinates bbox =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm coordinates)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm bbox)}]}))

-- | DSL accessor for the bbox field of hydra.ext.geojson.model.MultiLineString
multiLineStringBbox :: Typed.TypedTerm GeojsonModel.MultiLineString -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox)
multiLineStringBbox x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"),
        Model.projectionFieldName = (Model.Name "bbox")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.MultiLineString
multiLineStringCoordinates :: Typed.TypedTerm GeojsonModel.MultiLineString -> Typed.TypedTerm [GeojsonModel.LineString]
multiLineStringCoordinates x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"),
        Model.projectionFieldName = (Model.Name "coordinates")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.geojson.model.MultiLineString
multiLineStringMultiLineString :: Typed.TypedName GeojsonModel.MultiLineString
multiLineStringMultiLineString = Typed.TypedName (Model.Name "hydra.ext.geojson.model.MultiLineString")

-- | DSL updater for the bbox field of hydra.ext.geojson.model.MultiLineString
multiLineStringWithBbox :: Typed.TypedTerm GeojsonModel.MultiLineString -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiLineString
multiLineStringWithBbox original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"),
              Model.projectionFieldName = (Model.Name "coordinates")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the coordinates field of hydra.ext.geojson.model.MultiLineString
multiLineStringWithCoordinates :: Typed.TypedTerm GeojsonModel.MultiLineString -> Typed.TypedTerm [GeojsonModel.LineString] -> Typed.TypedTerm GeojsonModel.MultiLineString
multiLineStringWithCoordinates original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiLineString"),
              Model.projectionFieldName = (Model.Name "bbox")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.geojson.model.MultiPoint
multiPoint :: Typed.TypedTerm [GeojsonModel.Point] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiPoint
multiPoint coordinates bbox =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm coordinates)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm bbox)}]}))

-- | DSL accessor for the bbox field of hydra.ext.geojson.model.MultiPoint
multiPointBbox :: Typed.TypedTerm GeojsonModel.MultiPoint -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox)
multiPointBbox x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"),
        Model.projectionFieldName = (Model.Name "bbox")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.MultiPoint
multiPointCoordinates :: Typed.TypedTerm GeojsonModel.MultiPoint -> Typed.TypedTerm [GeojsonModel.Point]
multiPointCoordinates x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"),
        Model.projectionFieldName = (Model.Name "coordinates")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.geojson.model.MultiPoint
multiPointMultiPoint :: Typed.TypedName GeojsonModel.MultiPoint
multiPointMultiPoint = Typed.TypedName (Model.Name "hydra.ext.geojson.model.MultiPoint")

-- | DSL updater for the bbox field of hydra.ext.geojson.model.MultiPoint
multiPointWithBbox :: Typed.TypedTerm GeojsonModel.MultiPoint -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiPoint
multiPointWithBbox original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"),
              Model.projectionFieldName = (Model.Name "coordinates")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the coordinates field of hydra.ext.geojson.model.MultiPoint
multiPointWithCoordinates :: Typed.TypedTerm GeojsonModel.MultiPoint -> Typed.TypedTerm [GeojsonModel.Point] -> Typed.TypedTerm GeojsonModel.MultiPoint
multiPointWithCoordinates original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPoint"),
              Model.projectionFieldName = (Model.Name "bbox")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.geojson.model.MultiPolygon
multiPolygon :: Typed.TypedTerm [GeojsonModel.Polygon] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiPolygon
multiPolygon coordinates bbox =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm coordinates)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm bbox)}]}))

-- | DSL accessor for the bbox field of hydra.ext.geojson.model.MultiPolygon
multiPolygonBbox :: Typed.TypedTerm GeojsonModel.MultiPolygon -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox)
multiPolygonBbox x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"),
        Model.projectionFieldName = (Model.Name "bbox")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.MultiPolygon
multiPolygonCoordinates :: Typed.TypedTerm GeojsonModel.MultiPolygon -> Typed.TypedTerm [GeojsonModel.Polygon]
multiPolygonCoordinates x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"),
        Model.projectionFieldName = (Model.Name "coordinates")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.geojson.model.MultiPolygon
multiPolygonMultiPolygon :: Typed.TypedName GeojsonModel.MultiPolygon
multiPolygonMultiPolygon = Typed.TypedName (Model.Name "hydra.ext.geojson.model.MultiPolygon")

-- | DSL updater for the bbox field of hydra.ext.geojson.model.MultiPolygon
multiPolygonWithBbox :: Typed.TypedTerm GeojsonModel.MultiPolygon -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.MultiPolygon
multiPolygonWithBbox original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"),
              Model.projectionFieldName = (Model.Name "coordinates")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the coordinates field of hydra.ext.geojson.model.MultiPolygon
multiPolygonWithCoordinates :: Typed.TypedTerm GeojsonModel.MultiPolygon -> Typed.TypedTerm [GeojsonModel.Polygon] -> Typed.TypedTerm GeojsonModel.MultiPolygon
multiPolygonWithCoordinates original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.MultiPolygon"),
              Model.projectionFieldName = (Model.Name "bbox")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the feature variant of hydra.ext.geojson.model.Object
objectFeature :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm GeojsonModel.Object
objectFeature x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Object"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "feature"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the featureCollection variant of hydra.ext.geojson.model.Object
objectFeatureCollection :: Typed.TypedTerm GeojsonModel.FeatureCollection -> Typed.TypedTerm GeojsonModel.Object
objectFeatureCollection x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Object"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "featureCollection"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the geometry variant of hydra.ext.geojson.model.Object
objectGeometry :: Typed.TypedTerm GeojsonModel.Geometry -> Typed.TypedTerm GeojsonModel.Object
objectGeometry x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.geojson.model.Object"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "geometry"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.geojson.model.Object
objectObject :: Typed.TypedName GeojsonModel.Object
objectObject = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Object")

-- | DSL constructor for hydra.ext.geojson.model.Point
point :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Point
point coordinates bbox =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Point"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm coordinates)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm bbox)}]}))

-- | DSL accessor for the bbox field of hydra.ext.geojson.model.Point
pointBbox :: Typed.TypedTerm GeojsonModel.Point -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox)
pointBbox x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Point"),
        Model.projectionFieldName = (Model.Name "bbox")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.Point
pointCoordinates :: Typed.TypedTerm GeojsonModel.Point -> Typed.TypedTerm GeojsonModel.Position
pointCoordinates x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Point"),
        Model.projectionFieldName = (Model.Name "coordinates")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.geojson.model.Point
pointPoint :: Typed.TypedName GeojsonModel.Point
pointPoint = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Point")

-- | DSL updater for the bbox field of hydra.ext.geojson.model.Point
pointWithBbox :: Typed.TypedTerm GeojsonModel.Point -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Point
pointWithBbox original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Point"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Point"),
              Model.projectionFieldName = (Model.Name "coordinates")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the coordinates field of hydra.ext.geojson.model.Point
pointWithCoordinates :: Typed.TypedTerm GeojsonModel.Point -> Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm GeojsonModel.Point
pointWithCoordinates original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Point"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Point"),
              Model.projectionFieldName = (Model.Name "bbox")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.geojson.model.Polygon
polygon :: Typed.TypedTerm [GeojsonModel.Position] -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Polygon
polygon coordinates bbox =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm coordinates)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm bbox)}]}))

-- | DSL accessor for the bbox field of hydra.ext.geojson.model.Polygon
polygonBbox :: Typed.TypedTerm GeojsonModel.Polygon -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox)
polygonBbox x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"),
        Model.projectionFieldName = (Model.Name "bbox")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the coordinates field of hydra.ext.geojson.model.Polygon
polygonCoordinates :: Typed.TypedTerm GeojsonModel.Polygon -> Typed.TypedTerm [GeojsonModel.Position]
polygonCoordinates x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"),
        Model.projectionFieldName = (Model.Name "coordinates")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.geojson.model.Polygon
polygonPolygon :: Typed.TypedName GeojsonModel.Polygon
polygonPolygon = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Polygon")

-- | DSL updater for the bbox field of hydra.ext.geojson.model.Polygon
polygonWithBbox :: Typed.TypedTerm GeojsonModel.Polygon -> Typed.TypedTerm (Maybe GeojsonModel.BoundingBox) -> Typed.TypedTerm GeojsonModel.Polygon
polygonWithBbox original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"),
              Model.projectionFieldName = (Model.Name "coordinates")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the coordinates field of hydra.ext.geojson.model.Polygon
polygonWithCoordinates :: Typed.TypedTerm GeojsonModel.Polygon -> Typed.TypedTerm [GeojsonModel.Position] -> Typed.TypedTerm GeojsonModel.Polygon
polygonWithCoordinates original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "coordinates"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "bbox"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Polygon"),
              Model.projectionFieldName = (Model.Name "bbox")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.geojson.model.Position
position :: Typed.TypedTerm Double -> Typed.TypedTerm Double -> Typed.TypedTerm (Maybe Double) -> Typed.TypedTerm GeojsonModel.Position
position latitude longitude altitude =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "latitude"),
          Model.fieldTerm = (Typed.unTypedTerm latitude)},
        Model.Field {
          Model.fieldName = (Model.Name "longitude"),
          Model.fieldTerm = (Typed.unTypedTerm longitude)},
        Model.Field {
          Model.fieldName = (Model.Name "altitude"),
          Model.fieldTerm = (Typed.unTypedTerm altitude)}]}))

-- | DSL accessor for the altitude field of hydra.ext.geojson.model.Position
positionAltitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm (Maybe Double)
positionAltitude x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
        Model.projectionFieldName = (Model.Name "altitude")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the latitude field of hydra.ext.geojson.model.Position
positionLatitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm Double
positionLatitude x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
        Model.projectionFieldName = (Model.Name "latitude")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the longitude field of hydra.ext.geojson.model.Position
positionLongitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm Double
positionLongitude x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
        Model.projectionFieldName = (Model.Name "longitude")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.geojson.model.Position
positionPosition :: Typed.TypedName GeojsonModel.Position
positionPosition = Typed.TypedName (Model.Name "hydra.ext.geojson.model.Position")

-- | DSL updater for the altitude field of hydra.ext.geojson.model.Position
positionWithAltitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm (Maybe Double) -> Typed.TypedTerm GeojsonModel.Position
positionWithAltitude original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "latitude"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
              Model.projectionFieldName = (Model.Name "latitude")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "longitude"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
              Model.projectionFieldName = (Model.Name "longitude")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "altitude"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the latitude field of hydra.ext.geojson.model.Position
positionWithLatitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.Position
positionWithLatitude original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "latitude"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "longitude"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
              Model.projectionFieldName = (Model.Name "longitude")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "altitude"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
              Model.projectionFieldName = (Model.Name "altitude")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the longitude field of hydra.ext.geojson.model.Position
positionWithLongitude :: Typed.TypedTerm GeojsonModel.Position -> Typed.TypedTerm Double -> Typed.TypedTerm GeojsonModel.Position
positionWithLongitude original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "latitude"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
              Model.projectionFieldName = (Model.Name "latitude")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "longitude"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "altitude"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.geojson.model.Position"),
              Model.projectionFieldName = (Model.Name "altitude")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the body of hydra.ext.geojson.model.BoundingBox
unBoundingBox :: Typed.TypedTerm GeojsonModel.BoundingBox -> Typed.TypedTerm [GeojsonModel.CoordinateRange]
unBoundingBox x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.geojson.model.BoundingBox")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))