hydra-ext-0.18.0: src/main/haskell/Hydra/Ext/Dsl/Delta/Parquet.hs

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

-- | DSL functions for hydra.ext.delta.parquet

module Hydra.Ext.Dsl.Delta.Parquet where

import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Ext.Delta.Parquet as Parquet
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void

-- | DSL constructor for hydra.ext.delta.parquet.ArrayType
arrayType :: Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.ArrayType
arrayType elementType containsNull =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Typed.unTypedTerm elementType)},
        Model.Field {
          Model.fieldName = (Model.Name "containsNull"),
          Model.fieldTerm = (Typed.unTypedTerm containsNull)}]}))

-- | DSL name token for hydra.ext.delta.parquet.ArrayType
arrayTypeArrayType :: Typed.TypedName Parquet.ArrayType
arrayTypeArrayType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.ArrayType")

-- | DSL accessor for the containsNull field of hydra.ext.delta.parquet.ArrayType
arrayTypeContainsNull :: Typed.TypedTerm Parquet.ArrayType -> Typed.TypedTerm Bool
arrayTypeContainsNull x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"),
        Model.projectionFieldName = (Model.Name "containsNull")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the elementType field of hydra.ext.delta.parquet.ArrayType
arrayTypeElementType :: Typed.TypedTerm Parquet.ArrayType -> Typed.TypedTerm Parquet.DataType
arrayTypeElementType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"),
        Model.projectionFieldName = (Model.Name "elementType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the containsNull field of hydra.ext.delta.parquet.ArrayType
arrayTypeWithContainsNull :: Typed.TypedTerm Parquet.ArrayType -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.ArrayType
arrayTypeWithContainsNull original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"),
              Model.projectionFieldName = (Model.Name "elementType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "containsNull"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the elementType field of hydra.ext.delta.parquet.ArrayType
arrayTypeWithElementType :: Typed.TypedTerm Parquet.ArrayType -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Parquet.ArrayType
arrayTypeWithElementType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "containsNull"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.ArrayType"),
              Model.projectionFieldName = (Model.Name "containsNull")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeBasePrimitiveType :: Typed.TypedName Parquet.BasePrimitiveType
basePrimitiveTypeBasePrimitiveType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType")

-- | DSL injection for the binary variant of hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeBinary :: Typed.TypedTerm Parquet.BasePrimitiveType
basePrimitiveTypeBinary =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the boolean variant of hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeBoolean :: Typed.TypedTerm Parquet.BasePrimitiveType
basePrimitiveTypeBoolean =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "boolean"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the byte variant of hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeByte :: Typed.TypedTerm Parquet.BasePrimitiveType
basePrimitiveTypeByte =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "byte"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the date variant of hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeDate :: Typed.TypedTerm Parquet.BasePrimitiveType
basePrimitiveTypeDate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "date"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the double variant of hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeDouble :: Typed.TypedTerm Parquet.BasePrimitiveType
basePrimitiveTypeDouble =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "double"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the float variant of hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeFloat :: Typed.TypedTerm Parquet.BasePrimitiveType
basePrimitiveTypeFloat =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the integer variant of hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeInteger :: Typed.TypedTerm Parquet.BasePrimitiveType
basePrimitiveTypeInteger =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "integer"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the long variant of hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeLong :: Typed.TypedTerm Parquet.BasePrimitiveType
basePrimitiveTypeLong =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "long"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the short variant of hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeShort :: Typed.TypedTerm Parquet.BasePrimitiveType
basePrimitiveTypeShort =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "short"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the string variant of hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeString :: Typed.TypedTerm Parquet.BasePrimitiveType
basePrimitiveTypeString =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the timestamp variant of hydra.ext.delta.parquet.BasePrimitiveType
basePrimitiveTypeTimestamp :: Typed.TypedTerm Parquet.BasePrimitiveType
basePrimitiveTypeTimestamp =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.BasePrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "timestamp"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the array variant of hydra.ext.delta.parquet.DataType
dataTypeArray :: Typed.TypedTerm Parquet.ArrayType -> Typed.TypedTerm Parquet.DataType
dataTypeArray x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.DataType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "array"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the base variant of hydra.ext.delta.parquet.DataType
dataTypeBase :: Typed.TypedTerm Parquet.BasePrimitiveType -> Typed.TypedTerm Parquet.DataType
dataTypeBase x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.DataType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "base"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.delta.parquet.DataType
dataTypeDataType :: Typed.TypedName Parquet.DataType
dataTypeDataType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.DataType")

-- | DSL injection for the decimal variant of hydra.ext.delta.parquet.DataType
dataTypeDecimal :: Typed.TypedTerm Parquet.DecimalType -> Typed.TypedTerm Parquet.DataType
dataTypeDecimal x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.DataType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "decimal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the map variant of hydra.ext.delta.parquet.DataType
dataTypeMap :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Parquet.DataType
dataTypeMap x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.DataType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "map"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the struct variant of hydra.ext.delta.parquet.DataType
dataTypeStruct :: Typed.TypedTerm Parquet.StructType -> Typed.TypedTerm Parquet.DataType
dataTypeStruct x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.delta.parquet.DataType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "struct"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.delta.parquet.DecimalType
decimalType :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Parquet.DecimalType
decimalType precision scale =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "precision"),
          Model.fieldTerm = (Typed.unTypedTerm precision)},
        Model.Field {
          Model.fieldName = (Model.Name "scale"),
          Model.fieldTerm = (Typed.unTypedTerm scale)}]}))

-- | DSL name token for hydra.ext.delta.parquet.DecimalType
decimalTypeDecimalType :: Typed.TypedName Parquet.DecimalType
decimalTypeDecimalType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.DecimalType")

-- | DSL accessor for the precision field of hydra.ext.delta.parquet.DecimalType
decimalTypePrecision :: Typed.TypedTerm Parquet.DecimalType -> Typed.TypedTerm Int
decimalTypePrecision x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"),
        Model.projectionFieldName = (Model.Name "precision")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the scale field of hydra.ext.delta.parquet.DecimalType
decimalTypeScale :: Typed.TypedTerm Parquet.DecimalType -> Typed.TypedTerm Int
decimalTypeScale x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"),
        Model.projectionFieldName = (Model.Name "scale")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the precision field of hydra.ext.delta.parquet.DecimalType
decimalTypeWithPrecision :: Typed.TypedTerm Parquet.DecimalType -> Typed.TypedTerm Int -> Typed.TypedTerm Parquet.DecimalType
decimalTypeWithPrecision original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "precision"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "scale"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"),
              Model.projectionFieldName = (Model.Name "scale")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the scale field of hydra.ext.delta.parquet.DecimalType
decimalTypeWithScale :: Typed.TypedTerm Parquet.DecimalType -> Typed.TypedTerm Int -> Typed.TypedTerm Parquet.DecimalType
decimalTypeWithScale original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "precision"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.DecimalType"),
              Model.projectionFieldName = (Model.Name "precision")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "scale"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.delta.parquet.MapType
mapType :: Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.MapType
mapType keyType valueType valueContainsNull =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Typed.unTypedTerm keyType)},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Typed.unTypedTerm valueType)},
        Model.Field {
          Model.fieldName = (Model.Name "valueContainsNull"),
          Model.fieldTerm = (Typed.unTypedTerm valueContainsNull)}]}))

-- | DSL accessor for the keyType field of hydra.ext.delta.parquet.MapType
mapTypeKeyType :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Parquet.DataType
mapTypeKeyType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
        Model.projectionFieldName = (Model.Name "keyType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.delta.parquet.MapType
mapTypeMapType :: Typed.TypedName Parquet.MapType
mapTypeMapType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.MapType")

-- | DSL accessor for the valueContainsNull field of hydra.ext.delta.parquet.MapType
mapTypeValueContainsNull :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Bool
mapTypeValueContainsNull x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
        Model.projectionFieldName = (Model.Name "valueContainsNull")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the valueType field of hydra.ext.delta.parquet.MapType
mapTypeValueType :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Parquet.DataType
mapTypeValueType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
        Model.projectionFieldName = (Model.Name "valueType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the keyType field of hydra.ext.delta.parquet.MapType
mapTypeWithKeyType :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Parquet.MapType
mapTypeWithKeyType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
              Model.projectionFieldName = (Model.Name "valueType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueContainsNull"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
              Model.projectionFieldName = (Model.Name "valueContainsNull")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the valueContainsNull field of hydra.ext.delta.parquet.MapType
mapTypeWithValueContainsNull :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.MapType
mapTypeWithValueContainsNull original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
              Model.projectionFieldName = (Model.Name "keyType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
              Model.projectionFieldName = (Model.Name "valueType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueContainsNull"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the valueType field of hydra.ext.delta.parquet.MapType
mapTypeWithValueType :: Typed.TypedTerm Parquet.MapType -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Parquet.MapType
mapTypeWithValueType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keyType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
              Model.projectionFieldName = (Model.Name "keyType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "valueContainsNull"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.MapType"),
              Model.projectionFieldName = (Model.Name "valueContainsNull")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.delta.parquet.StructField
structField :: Typed.TypedTerm String -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.StructField
structField name dataType nullable =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "dataType"),
          Model.fieldTerm = (Typed.unTypedTerm dataType)},
        Model.Field {
          Model.fieldName = (Model.Name "nullable"),
          Model.fieldTerm = (Typed.unTypedTerm nullable)}]}))

-- | DSL accessor for the dataType field of hydra.ext.delta.parquet.StructField
structFieldDataType :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm Parquet.DataType
structFieldDataType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
        Model.projectionFieldName = (Model.Name "dataType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.delta.parquet.StructField
structFieldName :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm String
structFieldName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the nullable field of hydra.ext.delta.parquet.StructField
structFieldNullable :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm Bool
structFieldNullable x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
        Model.projectionFieldName = (Model.Name "nullable")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.delta.parquet.StructField
structFieldStructField :: Typed.TypedName Parquet.StructField
structFieldStructField = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.StructField")

-- | DSL updater for the dataType field of hydra.ext.delta.parquet.StructField
structFieldWithDataType :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm Parquet.DataType -> Typed.TypedTerm Parquet.StructField
structFieldWithDataType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "nullable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
              Model.projectionFieldName = (Model.Name "nullable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.delta.parquet.StructField
structFieldWithName :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm String -> Typed.TypedTerm Parquet.StructField
structFieldWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "dataType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
              Model.projectionFieldName = (Model.Name "dataType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
              Model.projectionFieldName = (Model.Name "nullable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the nullable field of hydra.ext.delta.parquet.StructField
structFieldWithNullable :: Typed.TypedTerm Parquet.StructField -> Typed.TypedTerm Bool -> Typed.TypedTerm Parquet.StructField
structFieldWithNullable original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructField"),
              Model.projectionFieldName = (Model.Name "dataType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullable"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.delta.parquet.StructType
structType :: Typed.TypedTerm [Parquet.StructField] -> Typed.TypedTerm Parquet.StructType
structType fields =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm fields)}]}))

-- | DSL accessor for the fields field of hydra.ext.delta.parquet.StructType
structTypeFields :: Typed.TypedTerm Parquet.StructType -> Typed.TypedTerm [Parquet.StructField]
structTypeFields x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.delta.parquet.StructType"),
        Model.projectionFieldName = (Model.Name "fields")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.delta.parquet.StructType
structTypeStructType :: Typed.TypedName Parquet.StructType
structTypeStructType = Typed.TypedName (Model.Name "hydra.ext.delta.parquet.StructType")

-- | DSL updater for the fields field of hydra.ext.delta.parquet.StructType
structTypeWithFields :: Typed.TypedTerm Parquet.StructType -> Typed.TypedTerm [Parquet.StructField] -> Typed.TypedTerm Parquet.StructType
structTypeWithFields original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.delta.parquet.StructType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))