hydra-ext-0.18.0: src/main/haskell/Hydra/Ext/Dsl/Stac/Items.hs

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

-- | DSL functions for hydra.ext.stac.items

module Hydra.Ext.Dsl.Stac.Items where

import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Ext.Dsl.Geojson.Model as DslGeojsonModel
import qualified Hydra.Ext.Dsl.Iana.Linkrelations as IanaLinkrelations
import qualified Hydra.Ext.Geojson.Model as GeojsonModel
import qualified Hydra.Ext.Iana.Linkrelations as Linkrelations
import qualified Hydra.Ext.Stac.Items as Items
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void
import qualified Data.Map as M

-- | DSL constructor for hydra.ext.stac.items.Asset
asset :: Typed.TypedTerm Items.Uri -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Items.MediaType) -> Typed.TypedTerm [Items.Role] -> Typed.TypedTerm Items.Asset
asset href title description type_ roles =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "href"),
          Model.fieldTerm = (Typed.unTypedTerm href)},
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Typed.unTypedTerm title)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "roles"),
          Model.fieldTerm = (Typed.unTypedTerm roles)}]}))

-- | DSL name token for hydra.ext.stac.items.Asset
assetAsset :: Typed.TypedName Items.Asset
assetAsset = Typed.TypedName (Model.Name "hydra.ext.stac.items.Asset")

-- | DSL accessor for the description field of hydra.ext.stac.items.Asset
assetDescription :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe String)
assetDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the href field of hydra.ext.stac.items.Asset
assetHref :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm Items.Uri
assetHref x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
        Model.projectionFieldName = (Model.Name "href")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the roles field of hydra.ext.stac.items.Asset
assetRoles :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm [Items.Role]
assetRoles x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
        Model.projectionFieldName = (Model.Name "roles")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the title field of hydra.ext.stac.items.Asset
assetTitle :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe String)
assetTitle x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
        Model.projectionFieldName = (Model.Name "title")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.stac.items.Asset
assetType :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe Items.MediaType)
assetType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the description field of hydra.ext.stac.items.Asset
assetWithDescription :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Items.Asset
assetWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "href"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "href")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "title")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "roles"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "roles")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the href field of hydra.ext.stac.items.Asset
assetWithHref :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm Items.Uri -> Typed.TypedTerm Items.Asset
assetWithHref original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "href"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "title")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "roles"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "roles")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the roles field of hydra.ext.stac.items.Asset
assetWithRoles :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm [Items.Role] -> Typed.TypedTerm Items.Asset
assetWithRoles original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "href"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "href")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "title")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "roles"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the title field of hydra.ext.stac.items.Asset
assetWithTitle :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Items.Asset
assetWithTitle original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "href"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "href")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "roles"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "roles")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.stac.items.Asset
assetWithType :: Typed.TypedTerm Items.Asset -> Typed.TypedTerm (Maybe Items.MediaType) -> Typed.TypedTerm Items.Asset
assetWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "href"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "href")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "title")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "roles"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Asset"),
              Model.projectionFieldName = (Model.Name "roles")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.stac.items.Item
item :: Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm Items.StacVersion -> Typed.TypedTerm [Items.Url] -> Typed.TypedTerm [Items.Link] -> Typed.TypedTerm (M.Map String Items.Asset) -> Typed.TypedTerm (Maybe GeojsonModel.Id) -> Typed.TypedTerm Items.Item
item feature stacVersion stacExtensions links assets collection =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "feature"),
          Model.fieldTerm = (Typed.unTypedTerm feature)},
        Model.Field {
          Model.fieldName = (Model.Name "stacVersion"),
          Model.fieldTerm = (Typed.unTypedTerm stacVersion)},
        Model.Field {
          Model.fieldName = (Model.Name "stacExtensions"),
          Model.fieldTerm = (Typed.unTypedTerm stacExtensions)},
        Model.Field {
          Model.fieldName = (Model.Name "links"),
          Model.fieldTerm = (Typed.unTypedTerm links)},
        Model.Field {
          Model.fieldName = (Model.Name "assets"),
          Model.fieldTerm = (Typed.unTypedTerm assets)},
        Model.Field {
          Model.fieldName = (Model.Name "collection"),
          Model.fieldTerm = (Typed.unTypedTerm collection)}]}))

-- | DSL accessor for the assets field of hydra.ext.stac.items.Item
itemAssets :: Typed.TypedTerm Items.Item -> Typed.TypedTerm (M.Map String Items.Asset)
itemAssets x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
        Model.projectionFieldName = (Model.Name "assets")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the collection field of hydra.ext.stac.items.Item
itemCollection :: Typed.TypedTerm Items.Item -> Typed.TypedTerm (Maybe GeojsonModel.Id)
itemCollection x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
        Model.projectionFieldName = (Model.Name "collection")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the feature field of hydra.ext.stac.items.Item
itemFeature :: Typed.TypedTerm Items.Item -> Typed.TypedTerm GeojsonModel.Feature
itemFeature x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
        Model.projectionFieldName = (Model.Name "feature")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.stac.items.Item
itemItem :: Typed.TypedName Items.Item
itemItem = Typed.TypedName (Model.Name "hydra.ext.stac.items.Item")

-- | DSL accessor for the links field of hydra.ext.stac.items.Item
itemLinks :: Typed.TypedTerm Items.Item -> Typed.TypedTerm [Items.Link]
itemLinks x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
        Model.projectionFieldName = (Model.Name "links")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the stacExtensions field of hydra.ext.stac.items.Item
itemStacExtensions :: Typed.TypedTerm Items.Item -> Typed.TypedTerm [Items.Url]
itemStacExtensions x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
        Model.projectionFieldName = (Model.Name "stacExtensions")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the stacVersion field of hydra.ext.stac.items.Item
itemStacVersion :: Typed.TypedTerm Items.Item -> Typed.TypedTerm Items.StacVersion
itemStacVersion x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
        Model.projectionFieldName = (Model.Name "stacVersion")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the assets field of hydra.ext.stac.items.Item
itemWithAssets :: Typed.TypedTerm Items.Item -> Typed.TypedTerm (M.Map String Items.Asset) -> Typed.TypedTerm Items.Item
itemWithAssets original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "feature"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "feature")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "stacVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "stacVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "stacExtensions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "stacExtensions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "links"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "links")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "assets"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "collection"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "collection")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the collection field of hydra.ext.stac.items.Item
itemWithCollection :: Typed.TypedTerm Items.Item -> Typed.TypedTerm (Maybe GeojsonModel.Id) -> Typed.TypedTerm Items.Item
itemWithCollection original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "feature"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "feature")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "stacVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "stacVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "stacExtensions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "stacExtensions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "links"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "links")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "assets"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "assets")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "collection"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the feature field of hydra.ext.stac.items.Item
itemWithFeature :: Typed.TypedTerm Items.Item -> Typed.TypedTerm GeojsonModel.Feature -> Typed.TypedTerm Items.Item
itemWithFeature original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "feature"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "stacVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "stacVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "stacExtensions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "stacExtensions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "links"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "links")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "assets"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "assets")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "collection"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "collection")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the links field of hydra.ext.stac.items.Item
itemWithLinks :: Typed.TypedTerm Items.Item -> Typed.TypedTerm [Items.Link] -> Typed.TypedTerm Items.Item
itemWithLinks original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "feature"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "feature")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "stacVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "stacVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "stacExtensions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "stacExtensions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "links"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "assets"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "assets")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "collection"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "collection")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the stacExtensions field of hydra.ext.stac.items.Item
itemWithStacExtensions :: Typed.TypedTerm Items.Item -> Typed.TypedTerm [Items.Url] -> Typed.TypedTerm Items.Item
itemWithStacExtensions original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "feature"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "feature")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "stacVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "stacVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "stacExtensions"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "links"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "links")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "assets"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "assets")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "collection"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "collection")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the stacVersion field of hydra.ext.stac.items.Item
itemWithStacVersion :: Typed.TypedTerm Items.Item -> Typed.TypedTerm Items.StacVersion -> Typed.TypedTerm Items.Item
itemWithStacVersion original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Item"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "feature"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "feature")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "stacVersion"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "stacExtensions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "stacExtensions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "links"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "links")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "assets"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "assets")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "collection"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Item"),
              Model.projectionFieldName = (Model.Name "collection")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.stac.items.Link
link :: Typed.TypedTerm Items.Url -> Typed.TypedTerm Items.RelationType -> Typed.TypedTerm (Maybe Items.MediaType) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Items.Link
link href rel type_ title =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Link"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "href"),
          Model.fieldTerm = (Typed.unTypedTerm href)},
        Model.Field {
          Model.fieldName = (Model.Name "rel"),
          Model.fieldTerm = (Typed.unTypedTerm rel)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Typed.unTypedTerm title)}]}))

-- | DSL accessor for the href field of hydra.ext.stac.items.Link
linkHref :: Typed.TypedTerm Items.Link -> Typed.TypedTerm Items.Url
linkHref x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
        Model.projectionFieldName = (Model.Name "href")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.stac.items.Link
linkLink :: Typed.TypedName Items.Link
linkLink = Typed.TypedName (Model.Name "hydra.ext.stac.items.Link")

-- | DSL accessor for the rel field of hydra.ext.stac.items.Link
linkRel :: Typed.TypedTerm Items.Link -> Typed.TypedTerm Items.RelationType
linkRel x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
        Model.projectionFieldName = (Model.Name "rel")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the title field of hydra.ext.stac.items.Link
linkTitle :: Typed.TypedTerm Items.Link -> Typed.TypedTerm (Maybe String)
linkTitle x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
        Model.projectionFieldName = (Model.Name "title")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.stac.items.Link
linkType :: Typed.TypedTerm Items.Link -> Typed.TypedTerm (Maybe Items.MediaType)
linkType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the href field of hydra.ext.stac.items.Link
linkWithHref :: Typed.TypedTerm Items.Link -> Typed.TypedTerm Items.Url -> Typed.TypedTerm Items.Link
linkWithHref original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Link"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "href"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "rel"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "rel")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "title")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the rel field of hydra.ext.stac.items.Link
linkWithRel :: Typed.TypedTerm Items.Link -> Typed.TypedTerm Items.RelationType -> Typed.TypedTerm Items.Link
linkWithRel original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Link"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "href"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "href")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rel"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "title")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the title field of hydra.ext.stac.items.Link
linkWithTitle :: Typed.TypedTerm Items.Link -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Items.Link
linkWithTitle original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Link"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "href"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "href")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rel"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "rel")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.stac.items.Link
linkWithType :: Typed.TypedTerm Items.Link -> Typed.TypedTerm (Maybe Items.MediaType) -> Typed.TypedTerm Items.Link
linkWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.stac.items.Link"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "href"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "href")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rel"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "rel")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.stac.items.Link"),
              Model.projectionFieldName = (Model.Name "title")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.stac.items.MediaType wrapper
mediaType :: Typed.TypedTerm String -> Typed.TypedTerm Items.MediaType
mediaType x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.stac.items.MediaType"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.stac.items.MediaType
mediaTypeMediaType :: Typed.TypedName Items.MediaType
mediaTypeMediaType = Typed.TypedName (Model.Name "hydra.ext.stac.items.MediaType")

-- | DSL injection for the iana variant of hydra.ext.stac.items.RelationType
relationTypeIana :: Typed.TypedTerm Linkrelations.LinkRelationType -> Typed.TypedTerm Items.RelationType
relationTypeIana x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.RelationType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "iana"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the other variant of hydra.ext.stac.items.RelationType
relationTypeOther :: Typed.TypedTerm String -> Typed.TypedTerm Items.RelationType
relationTypeOther x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.RelationType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "other"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.stac.items.RelationType
relationTypeRelationType :: Typed.TypedName Items.RelationType
relationTypeRelationType = Typed.TypedName (Model.Name "hydra.ext.stac.items.RelationType")

-- | DSL injection for the stac variant of hydra.ext.stac.items.RelationType
relationTypeStac :: Typed.TypedTerm Items.StacRelationType -> Typed.TypedTerm Items.RelationType
relationTypeStac x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.RelationType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "stac"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the data variant of hydra.ext.stac.items.Role
roleData :: Typed.TypedTerm Items.Role
roleData =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.Role"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "data"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the metadata variant of hydra.ext.stac.items.Role
roleMetadata :: Typed.TypedTerm Items.Role
roleMetadata =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.Role"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "metadata"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the other variant of hydra.ext.stac.items.Role
roleOther :: Typed.TypedTerm String -> Typed.TypedTerm Items.Role
roleOther x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.Role"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "other"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the overview variant of hydra.ext.stac.items.Role
roleOverview :: Typed.TypedTerm Items.Role
roleOverview =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.Role"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "overview"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.stac.items.Role
roleRole :: Typed.TypedName Items.Role
roleRole = Typed.TypedName (Model.Name "hydra.ext.stac.items.Role")

-- | DSL injection for the thumbnail variant of hydra.ext.stac.items.Role
roleThumbnail :: Typed.TypedTerm Items.Role
roleThumbnail =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.Role"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "thumbnail"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the collection variant of hydra.ext.stac.items.StacRelationType
stacRelationTypeCollection :: Typed.TypedTerm Items.StacRelationType
stacRelationTypeCollection =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.StacRelationType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "collection"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the derivedFrom variant of hydra.ext.stac.items.StacRelationType
stacRelationTypeDerivedFrom :: Typed.TypedTerm Items.StacRelationType
stacRelationTypeDerivedFrom =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.StacRelationType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "derivedFrom"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the parent variant of hydra.ext.stac.items.StacRelationType
stacRelationTypeParent :: Typed.TypedTerm Items.StacRelationType
stacRelationTypeParent =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.StacRelationType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "parent"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the root variant of hydra.ext.stac.items.StacRelationType
stacRelationTypeRoot :: Typed.TypedTerm Items.StacRelationType
stacRelationTypeRoot =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.StacRelationType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "root"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the self variant of hydra.ext.stac.items.StacRelationType
stacRelationTypeSelf :: Typed.TypedTerm Items.StacRelationType
stacRelationTypeSelf =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.stac.items.StacRelationType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "self"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.stac.items.StacRelationType
stacRelationTypeStacRelationType :: Typed.TypedName Items.StacRelationType
stacRelationTypeStacRelationType = Typed.TypedName (Model.Name "hydra.ext.stac.items.StacRelationType")

-- | DSL constructor for the hydra.ext.stac.items.StacVersion wrapper
stacVersion :: Typed.TypedTerm String -> Typed.TypedTerm Items.StacVersion
stacVersion x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.stac.items.StacVersion"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.stac.items.StacVersion
stacVersionStacVersion :: Typed.TypedName Items.StacVersion
stacVersionStacVersion = Typed.TypedName (Model.Name "hydra.ext.stac.items.StacVersion")

-- | DSL accessor for the body of hydra.ext.stac.items.MediaType
unMediaType :: Typed.TypedTerm Items.MediaType -> Typed.TypedTerm String
unMediaType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.stac.items.MediaType")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.stac.items.StacVersion
unStacVersion :: Typed.TypedTerm Items.StacVersion -> Typed.TypedTerm String
unStacVersion x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.stac.items.StacVersion")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.stac.items.Uri
unUri :: Typed.TypedTerm Items.Uri -> Typed.TypedTerm String
unUri x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.stac.items.Uri")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.stac.items.Url
unUrl :: Typed.TypedTerm Items.Url -> Typed.TypedTerm String
unUrl x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.stac.items.Url")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.ext.stac.items.Uri wrapper
uri :: Typed.TypedTerm String -> Typed.TypedTerm Items.Uri
uri x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.stac.items.Uri"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.stac.items.Uri
uriUri :: Typed.TypedName Items.Uri
uriUri = Typed.TypedName (Model.Name "hydra.ext.stac.items.Uri")

-- | DSL constructor for the hydra.ext.stac.items.Url wrapper
url :: Typed.TypedTerm String -> Typed.TypedTerm Items.Url
url x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.stac.items.Url"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.stac.items.Url
urlUrl :: Typed.TypedName Items.Url
urlUrl = Typed.TypedName (Model.Name "hydra.ext.stac.items.Url")