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

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

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

module Hydra.Ext.Dsl.Parquet.Format where

import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Ext.Parquet.Format as Format
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.ByteString as B
import qualified Data.Int as I

-- | DSL constructor for hydra.ext.parquet.format.AesGcmCtrV1
aesGcmCtrV1 :: Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.AesGcmCtrV1
aesGcmCtrV1 aadPrefix aadFileUnique supplyAadPrefix =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "aadPrefix"),
          Model.fieldTerm = (Typed.unTypedTerm aadPrefix)},
        Model.Field {
          Model.fieldName = (Model.Name "aadFileUnique"),
          Model.fieldTerm = (Typed.unTypedTerm aadFileUnique)},
        Model.Field {
          Model.fieldName = (Model.Name "supplyAadPrefix"),
          Model.fieldTerm = (Typed.unTypedTerm supplyAadPrefix)}]}))

-- | DSL accessor for the aadFileUnique field of hydra.ext.parquet.format.AesGcmCtrV1
aesGcmCtrV1AadFileUnique :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe B.ByteString)
aesGcmCtrV1AadFileUnique x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
        Model.projectionFieldName = (Model.Name "aadFileUnique")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the aadPrefix field of hydra.ext.parquet.format.AesGcmCtrV1
aesGcmCtrV1AadPrefix :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe B.ByteString)
aesGcmCtrV1AadPrefix x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
        Model.projectionFieldName = (Model.Name "aadPrefix")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.AesGcmCtrV1
aesGcmCtrV1AesGcmCtrV1 :: Typed.TypedName Format.AesGcmCtrV1
aesGcmCtrV1AesGcmCtrV1 = Typed.TypedName (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1")

-- | DSL accessor for the supplyAadPrefix field of hydra.ext.parquet.format.AesGcmCtrV1
aesGcmCtrV1SupplyAadPrefix :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe Bool)
aesGcmCtrV1SupplyAadPrefix x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
        Model.projectionFieldName = (Model.Name "supplyAadPrefix")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the aadFileUnique field of hydra.ext.parquet.format.AesGcmCtrV1
aesGcmCtrV1WithAadFileUnique :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.AesGcmCtrV1
aesGcmCtrV1WithAadFileUnique original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "aadPrefix"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
              Model.projectionFieldName = (Model.Name "aadPrefix")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aadFileUnique"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "supplyAadPrefix"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
              Model.projectionFieldName = (Model.Name "supplyAadPrefix")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the aadPrefix field of hydra.ext.parquet.format.AesGcmCtrV1
aesGcmCtrV1WithAadPrefix :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.AesGcmCtrV1
aesGcmCtrV1WithAadPrefix original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "aadPrefix"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "aadFileUnique"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
              Model.projectionFieldName = (Model.Name "aadFileUnique")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "supplyAadPrefix"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
              Model.projectionFieldName = (Model.Name "supplyAadPrefix")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the supplyAadPrefix field of hydra.ext.parquet.format.AesGcmCtrV1
aesGcmCtrV1WithSupplyAadPrefix :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.AesGcmCtrV1
aesGcmCtrV1WithSupplyAadPrefix original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "aadPrefix"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
              Model.projectionFieldName = (Model.Name "aadPrefix")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aadFileUnique"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmCtrV1"),
              Model.projectionFieldName = (Model.Name "aadFileUnique")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "supplyAadPrefix"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.parquet.format.AesGcmV1
aesGcmV1 :: Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.AesGcmV1
aesGcmV1 aadPrefix aadFileUnique supplyAadPrefix =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "aadPrefix"),
          Model.fieldTerm = (Typed.unTypedTerm aadPrefix)},
        Model.Field {
          Model.fieldName = (Model.Name "aadFileUnique"),
          Model.fieldTerm = (Typed.unTypedTerm aadFileUnique)},
        Model.Field {
          Model.fieldName = (Model.Name "supplyAadPrefix"),
          Model.fieldTerm = (Typed.unTypedTerm supplyAadPrefix)}]}))

-- | DSL accessor for the aadFileUnique field of hydra.ext.parquet.format.AesGcmV1
aesGcmV1AadFileUnique :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe B.ByteString)
aesGcmV1AadFileUnique x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
        Model.projectionFieldName = (Model.Name "aadFileUnique")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the aadPrefix field of hydra.ext.parquet.format.AesGcmV1
aesGcmV1AadPrefix :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe B.ByteString)
aesGcmV1AadPrefix x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
        Model.projectionFieldName = (Model.Name "aadPrefix")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.AesGcmV1
aesGcmV1AesGcmV1 :: Typed.TypedName Format.AesGcmV1
aesGcmV1AesGcmV1 = Typed.TypedName (Model.Name "hydra.ext.parquet.format.AesGcmV1")

-- | DSL accessor for the supplyAadPrefix field of hydra.ext.parquet.format.AesGcmV1
aesGcmV1SupplyAadPrefix :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe Bool)
aesGcmV1SupplyAadPrefix x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
        Model.projectionFieldName = (Model.Name "supplyAadPrefix")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the aadFileUnique field of hydra.ext.parquet.format.AesGcmV1
aesGcmV1WithAadFileUnique :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.AesGcmV1
aesGcmV1WithAadFileUnique original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "aadPrefix"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
              Model.projectionFieldName = (Model.Name "aadPrefix")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aadFileUnique"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "supplyAadPrefix"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
              Model.projectionFieldName = (Model.Name "supplyAadPrefix")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the aadPrefix field of hydra.ext.parquet.format.AesGcmV1
aesGcmV1WithAadPrefix :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.AesGcmV1
aesGcmV1WithAadPrefix original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "aadPrefix"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "aadFileUnique"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
              Model.projectionFieldName = (Model.Name "aadFileUnique")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "supplyAadPrefix"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
              Model.projectionFieldName = (Model.Name "supplyAadPrefix")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the supplyAadPrefix field of hydra.ext.parquet.format.AesGcmV1
aesGcmV1WithSupplyAadPrefix :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.AesGcmV1
aesGcmV1WithSupplyAadPrefix original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "aadPrefix"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
              Model.projectionFieldName = (Model.Name "aadPrefix")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aadFileUnique"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.AesGcmV1"),
              Model.projectionFieldName = (Model.Name "aadFileUnique")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "supplyAadPrefix"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the block variant of hydra.ext.parquet.format.BloomFilterAlgorithm
bloomFilterAlgorithmBlock :: Typed.TypedTerm Format.BloomFilterAlgorithm
bloomFilterAlgorithmBlock =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterAlgorithm"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.parquet.format.BloomFilterAlgorithm
bloomFilterAlgorithmBloomFilterAlgorithm :: Typed.TypedName Format.BloomFilterAlgorithm
bloomFilterAlgorithmBloomFilterAlgorithm = Typed.TypedName (Model.Name "hydra.ext.parquet.format.BloomFilterAlgorithm")

-- | DSL name token for hydra.ext.parquet.format.BloomFilterCompression
bloomFilterCompressionBloomFilterCompression :: Typed.TypedName Format.BloomFilterCompression
bloomFilterCompressionBloomFilterCompression =
    Typed.TypedName (Model.Name "hydra.ext.parquet.format.BloomFilterCompression")

-- | DSL injection for the uncompressed variant of hydra.ext.parquet.format.BloomFilterCompression
bloomFilterCompressionUncompressed :: Typed.TypedTerm Format.BloomFilterCompression
bloomFilterCompressionUncompressed =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterCompression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uncompressed"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.parquet.format.BloomFilterHash
bloomFilterHashBloomFilterHash :: Typed.TypedName Format.BloomFilterHash
bloomFilterHashBloomFilterHash = Typed.TypedName (Model.Name "hydra.ext.parquet.format.BloomFilterHash")

-- | DSL injection for the xxhash variant of hydra.ext.parquet.format.BloomFilterHash
bloomFilterHashXxhash :: Typed.TypedTerm Format.BloomFilterHash
bloomFilterHashXxhash =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHash"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "xxhash"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.parquet.format.BloomFilterHeader
bloomFilterHeader :: Typed.TypedTerm Int -> Typed.TypedTerm Format.BloomFilterAlgorithm -> Typed.TypedTerm Format.BloomFilterHash -> Typed.TypedTerm Format.BloomFilterCompression -> Typed.TypedTerm Format.BloomFilterHeader
bloomFilterHeader numBytes algorithm hash compression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numBytes"),
          Model.fieldTerm = (Typed.unTypedTerm numBytes)},
        Model.Field {
          Model.fieldName = (Model.Name "algorithm"),
          Model.fieldTerm = (Typed.unTypedTerm algorithm)},
        Model.Field {
          Model.fieldName = (Model.Name "hash"),
          Model.fieldTerm = (Typed.unTypedTerm hash)},
        Model.Field {
          Model.fieldName = (Model.Name "compression"),
          Model.fieldTerm = (Typed.unTypedTerm compression)}]}))

-- | DSL accessor for the algorithm field of hydra.ext.parquet.format.BloomFilterHeader
bloomFilterHeaderAlgorithm :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterAlgorithm
bloomFilterHeaderAlgorithm x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
        Model.projectionFieldName = (Model.Name "algorithm")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.BloomFilterHeader
bloomFilterHeaderBloomFilterHeader :: Typed.TypedName Format.BloomFilterHeader
bloomFilterHeaderBloomFilterHeader = Typed.TypedName (Model.Name "hydra.ext.parquet.format.BloomFilterHeader")

-- | DSL accessor for the compression field of hydra.ext.parquet.format.BloomFilterHeader
bloomFilterHeaderCompression :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterCompression
bloomFilterHeaderCompression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
        Model.projectionFieldName = (Model.Name "compression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the hash field of hydra.ext.parquet.format.BloomFilterHeader
bloomFilterHeaderHash :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterHash
bloomFilterHeaderHash x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
        Model.projectionFieldName = (Model.Name "hash")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the numBytes field of hydra.ext.parquet.format.BloomFilterHeader
bloomFilterHeaderNumBytes :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Int
bloomFilterHeaderNumBytes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
        Model.projectionFieldName = (Model.Name "numBytes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the algorithm field of hydra.ext.parquet.format.BloomFilterHeader
bloomFilterHeaderWithAlgorithm :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterAlgorithm -> Typed.TypedTerm Format.BloomFilterHeader
bloomFilterHeaderWithAlgorithm original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numBytes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "numBytes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "algorithm"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "hash"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "hash")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "compression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the compression field of hydra.ext.parquet.format.BloomFilterHeader
bloomFilterHeaderWithCompression :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterCompression -> Typed.TypedTerm Format.BloomFilterHeader
bloomFilterHeaderWithCompression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numBytes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "numBytes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "algorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "algorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hash"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "hash")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the hash field of hydra.ext.parquet.format.BloomFilterHeader
bloomFilterHeaderWithHash :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Format.BloomFilterHash -> Typed.TypedTerm Format.BloomFilterHeader
bloomFilterHeaderWithHash original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numBytes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "numBytes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "algorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "algorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hash"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "compression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "compression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the numBytes field of hydra.ext.parquet.format.BloomFilterHeader
bloomFilterHeaderWithNumBytes :: Typed.TypedTerm Format.BloomFilterHeader -> Typed.TypedTerm Int -> Typed.TypedTerm Format.BloomFilterHeader
bloomFilterHeaderWithNumBytes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numBytes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "algorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "algorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hash"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "hash")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.BloomFilterHeader"),
              Model.projectionFieldName = (Model.Name "compression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the ascending variant of hydra.ext.parquet.format.BoundaryOrder
boundaryOrderAscending :: Typed.TypedTerm Format.BoundaryOrder
boundaryOrderAscending =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BoundaryOrder"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ascending"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.parquet.format.BoundaryOrder
boundaryOrderBoundaryOrder :: Typed.TypedName Format.BoundaryOrder
boundaryOrderBoundaryOrder = Typed.TypedName (Model.Name "hydra.ext.parquet.format.BoundaryOrder")

-- | DSL injection for the descending variant of hydra.ext.parquet.format.BoundaryOrder
boundaryOrderDescending :: Typed.TypedTerm Format.BoundaryOrder
boundaryOrderDescending =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BoundaryOrder"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "descending"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unordered variant of hydra.ext.parquet.format.BoundaryOrder
boundaryOrderUnordered :: Typed.TypedTerm Format.BoundaryOrder
boundaryOrderUnordered =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.BoundaryOrder"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unordered"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.parquet.format.ColumnChunk
columnChunk :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm (Maybe Format.ColumnMetaData) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Format.ColumnCryptoMetaData) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.ColumnChunk
columnChunk filePath fileOffset metaData offsetIndexOffset offsetIndexLength columnIndexOffset columnIndexLength cryptoMetadata encryptedColumnMetadata =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "filePath"),
          Model.fieldTerm = (Typed.unTypedTerm filePath)},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Typed.unTypedTerm fileOffset)},
        Model.Field {
          Model.fieldName = (Model.Name "metaData"),
          Model.fieldTerm = (Typed.unTypedTerm metaData)},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexOffset"),
          Model.fieldTerm = (Typed.unTypedTerm offsetIndexOffset)},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexLength"),
          Model.fieldTerm = (Typed.unTypedTerm offsetIndexLength)},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexOffset"),
          Model.fieldTerm = (Typed.unTypedTerm columnIndexOffset)},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexLength"),
          Model.fieldTerm = (Typed.unTypedTerm columnIndexLength)},
        Model.Field {
          Model.fieldName = (Model.Name "cryptoMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm cryptoMetadata)},
        Model.Field {
          Model.fieldName = (Model.Name "encryptedColumnMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm encryptedColumnMetadata)}]}))

-- | DSL name token for hydra.ext.parquet.format.ColumnChunk
columnChunkColumnChunk :: Typed.TypedName Format.ColumnChunk
columnChunkColumnChunk = Typed.TypedName (Model.Name "hydra.ext.parquet.format.ColumnChunk")

-- | DSL accessor for the columnIndexLength field of hydra.ext.parquet.format.ColumnChunk
columnChunkColumnIndexLength :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Int)
columnChunkColumnIndexLength x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
        Model.projectionFieldName = (Model.Name "columnIndexLength")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the columnIndexOffset field of hydra.ext.parquet.format.ColumnChunk
columnChunkColumnIndexOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe I.Int64)
columnChunkColumnIndexOffset x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
        Model.projectionFieldName = (Model.Name "columnIndexOffset")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the cryptoMetadata field of hydra.ext.parquet.format.ColumnChunk
columnChunkCryptoMetadata :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Format.ColumnCryptoMetaData)
columnChunkCryptoMetadata x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
        Model.projectionFieldName = (Model.Name "cryptoMetadata")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the encryptedColumnMetadata field of hydra.ext.parquet.format.ColumnChunk
columnChunkEncryptedColumnMetadata :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe B.ByteString)
columnChunkEncryptedColumnMetadata x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
        Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the fileOffset field of hydra.ext.parquet.format.ColumnChunk
columnChunkFileOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm I.Int64
columnChunkFileOffset x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
        Model.projectionFieldName = (Model.Name "fileOffset")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the filePath field of hydra.ext.parquet.format.ColumnChunk
columnChunkFilePath :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe String)
columnChunkFilePath x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
        Model.projectionFieldName = (Model.Name "filePath")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the metaData field of hydra.ext.parquet.format.ColumnChunk
columnChunkMetaData :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Format.ColumnMetaData)
columnChunkMetaData x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
        Model.projectionFieldName = (Model.Name "metaData")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the offsetIndexLength field of hydra.ext.parquet.format.ColumnChunk
columnChunkOffsetIndexLength :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Int)
columnChunkOffsetIndexLength x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
        Model.projectionFieldName = (Model.Name "offsetIndexLength")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the offsetIndexOffset field of hydra.ext.parquet.format.ColumnChunk
columnChunkOffsetIndexOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe I.Int64)
columnChunkOffsetIndexOffset x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
        Model.projectionFieldName = (Model.Name "offsetIndexOffset")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the columnIndexLength field of hydra.ext.parquet.format.ColumnChunk
columnChunkWithColumnIndexLength :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.ColumnChunk
columnChunkWithColumnIndexLength original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "filePath"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "filePath")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "metaData"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "metaData")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexLength"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "cryptoMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "cryptoMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptedColumnMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the columnIndexOffset field of hydra.ext.parquet.format.ColumnChunk
columnChunkWithColumnIndexOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnChunk
columnChunkWithColumnIndexOffset original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "filePath"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "filePath")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "metaData"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "metaData")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexOffset"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "cryptoMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "cryptoMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptedColumnMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the cryptoMetadata field of hydra.ext.parquet.format.ColumnChunk
columnChunkWithCryptoMetadata :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Format.ColumnCryptoMetaData) -> Typed.TypedTerm Format.ColumnChunk
columnChunkWithCryptoMetadata original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "filePath"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "filePath")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "metaData"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "metaData")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "cryptoMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "encryptedColumnMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the encryptedColumnMetadata field of hydra.ext.parquet.format.ColumnChunk
columnChunkWithEncryptedColumnMetadata :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.ColumnChunk
columnChunkWithEncryptedColumnMetadata original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "filePath"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "filePath")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "metaData"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "metaData")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "cryptoMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "cryptoMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptedColumnMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the fileOffset field of hydra.ext.parquet.format.ColumnChunk
columnChunkWithFileOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.ColumnChunk
columnChunkWithFileOffset original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "filePath"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "filePath")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "metaData"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "metaData")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "cryptoMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "cryptoMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptedColumnMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the filePath field of hydra.ext.parquet.format.ColumnChunk
columnChunkWithFilePath :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.ColumnChunk
columnChunkWithFilePath original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "filePath"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "metaData"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "metaData")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "cryptoMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "cryptoMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptedColumnMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the metaData field of hydra.ext.parquet.format.ColumnChunk
columnChunkWithMetaData :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Format.ColumnMetaData) -> Typed.TypedTerm Format.ColumnChunk
columnChunkWithMetaData original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "filePath"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "filePath")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "metaData"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "cryptoMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "cryptoMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptedColumnMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the offsetIndexLength field of hydra.ext.parquet.format.ColumnChunk
columnChunkWithOffsetIndexLength :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.ColumnChunk
columnChunkWithOffsetIndexLength original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "filePath"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "filePath")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "metaData"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "metaData")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexLength"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "cryptoMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "cryptoMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptedColumnMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the offsetIndexOffset field of hydra.ext.parquet.format.ColumnChunk
columnChunkWithOffsetIndexOffset :: Typed.TypedTerm Format.ColumnChunk -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnChunk
columnChunkWithOffsetIndexOffset original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "filePath"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "filePath")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "metaData"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "metaData")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexOffset"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "offsetIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "offsetIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnIndexLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "columnIndexLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "cryptoMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "cryptoMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptedColumnMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnChunk"),
              Model.projectionFieldName = (Model.Name "encryptedColumnMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.parquet.format.ColumnCryptoMetaData
columnCryptoMetaDataColumnCryptoMetaData :: Typed.TypedName Format.ColumnCryptoMetaData
columnCryptoMetaDataColumnCryptoMetaData = Typed.TypedName (Model.Name "hydra.ext.parquet.format.ColumnCryptoMetaData")

-- | DSL injection for the encryptionWithColumnKey variant of hydra.ext.parquet.format.ColumnCryptoMetaData
columnCryptoMetaDataEncryptionWithColumnKey :: Typed.TypedTerm Format.EncryptionWithColumnKey -> Typed.TypedTerm Format.ColumnCryptoMetaData
columnCryptoMetaDataEncryptionWithColumnKey x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnCryptoMetaData"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "encryptionWithColumnKey"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the encryptionWithFooterKey variant of hydra.ext.parquet.format.ColumnCryptoMetaData
columnCryptoMetaDataEncryptionWithFooterKey :: Typed.TypedTerm Format.EncryptionWithFooterKey -> Typed.TypedTerm Format.ColumnCryptoMetaData
columnCryptoMetaDataEncryptionWithFooterKey x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnCryptoMetaData"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "encryptionWithFooterKey"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.parquet.format.ColumnIndex
columnIndex :: Typed.TypedTerm [Bool] -> Typed.TypedTerm [B.ByteString] -> Typed.TypedTerm [B.ByteString] -> Typed.TypedTerm Format.BoundaryOrder -> Typed.TypedTerm (Maybe [I.Int64]) -> Typed.TypedTerm Format.ColumnIndex
columnIndex nullPages minValues maxValues boundaryOrder nullCounts =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "nullPages"),
          Model.fieldTerm = (Typed.unTypedTerm nullPages)},
        Model.Field {
          Model.fieldName = (Model.Name "minValues"),
          Model.fieldTerm = (Typed.unTypedTerm minValues)},
        Model.Field {
          Model.fieldName = (Model.Name "maxValues"),
          Model.fieldTerm = (Typed.unTypedTerm maxValues)},
        Model.Field {
          Model.fieldName = (Model.Name "boundaryOrder"),
          Model.fieldTerm = (Typed.unTypedTerm boundaryOrder)},
        Model.Field {
          Model.fieldName = (Model.Name "nullCounts"),
          Model.fieldTerm = (Typed.unTypedTerm nullCounts)}]}))

-- | DSL accessor for the boundaryOrder field of hydra.ext.parquet.format.ColumnIndex
columnIndexBoundaryOrder :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm Format.BoundaryOrder
columnIndexBoundaryOrder x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
        Model.projectionFieldName = (Model.Name "boundaryOrder")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.ColumnIndex
columnIndexColumnIndex :: Typed.TypedName Format.ColumnIndex
columnIndexColumnIndex = Typed.TypedName (Model.Name "hydra.ext.parquet.format.ColumnIndex")

-- | DSL accessor for the maxValues field of hydra.ext.parquet.format.ColumnIndex
columnIndexMaxValues :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [B.ByteString]
columnIndexMaxValues x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
        Model.projectionFieldName = (Model.Name "maxValues")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the minValues field of hydra.ext.parquet.format.ColumnIndex
columnIndexMinValues :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [B.ByteString]
columnIndexMinValues x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
        Model.projectionFieldName = (Model.Name "minValues")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the nullCounts field of hydra.ext.parquet.format.ColumnIndex
columnIndexNullCounts :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm (Maybe [I.Int64])
columnIndexNullCounts x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
        Model.projectionFieldName = (Model.Name "nullCounts")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the nullPages field of hydra.ext.parquet.format.ColumnIndex
columnIndexNullPages :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [Bool]
columnIndexNullPages x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
        Model.projectionFieldName = (Model.Name "nullPages")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the boundaryOrder field of hydra.ext.parquet.format.ColumnIndex
columnIndexWithBoundaryOrder :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm Format.BoundaryOrder -> Typed.TypedTerm Format.ColumnIndex
columnIndexWithBoundaryOrder original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "nullPages"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "nullPages")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "minValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "maxValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "boundaryOrder"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "nullCounts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "nullCounts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the maxValues field of hydra.ext.parquet.format.ColumnIndex
columnIndexWithMaxValues :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [B.ByteString] -> Typed.TypedTerm Format.ColumnIndex
columnIndexWithMaxValues original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "nullPages"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "nullPages")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "minValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxValues"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "boundaryOrder"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "boundaryOrder")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullCounts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "nullCounts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the minValues field of hydra.ext.parquet.format.ColumnIndex
columnIndexWithMinValues :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [B.ByteString] -> Typed.TypedTerm Format.ColumnIndex
columnIndexWithMinValues original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "nullPages"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "nullPages")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minValues"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "maxValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "maxValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "boundaryOrder"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "boundaryOrder")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullCounts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "nullCounts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the nullCounts field of hydra.ext.parquet.format.ColumnIndex
columnIndexWithNullCounts :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm (Maybe [I.Int64]) -> Typed.TypedTerm Format.ColumnIndex
columnIndexWithNullCounts original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "nullPages"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "nullPages")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "minValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "maxValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "boundaryOrder"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "boundaryOrder")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullCounts"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the nullPages field of hydra.ext.parquet.format.ColumnIndex
columnIndexWithNullPages :: Typed.TypedTerm Format.ColumnIndex -> Typed.TypedTerm [Bool] -> Typed.TypedTerm Format.ColumnIndex
columnIndexWithNullPages original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "nullPages"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "minValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "minValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "maxValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "boundaryOrder"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "boundaryOrder")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullCounts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnIndex"),
              Model.projectionFieldName = (Model.Name "nullCounts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.parquet.format.ColumnMetaData
columnMetaData :: Typed.TypedTerm Format.Type -> Typed.TypedTerm [Format.Encoding] -> Typed.TypedTerm [String] -> Typed.TypedTerm Format.CompressionCodec -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm (Maybe [Format.KeyValue]) -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm (Maybe [Format.PageEncodingStats]) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnMetaData
columnMetaData type_ encodings pathInSchema codec numValues totalUncompressedSize totalCompressedSize keyValueMetadata dataPageOffset indexPageOffset dictionaryPageOffset statistics encodingStats bloomFilterOffset =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Typed.unTypedTerm encodings)},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Typed.unTypedTerm pathInSchema)},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Typed.unTypedTerm codec)},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Typed.unTypedTerm numValues)},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Typed.unTypedTerm totalUncompressedSize)},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Typed.unTypedTerm totalCompressedSize)},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm keyValueMetadata)},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Typed.unTypedTerm dataPageOffset)},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Typed.unTypedTerm indexPageOffset)},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Typed.unTypedTerm dictionaryPageOffset)},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Typed.unTypedTerm statistics)},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Typed.unTypedTerm encodingStats)},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Typed.unTypedTerm bloomFilterOffset)}]}))

-- | DSL accessor for the bloomFilterOffset field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataBloomFilterOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64)
columnMetaDataBloomFilterOffset x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the codec field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataCodec :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm Format.CompressionCodec
columnMetaDataCodec x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "codec")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.ColumnMetaData
columnMetaDataColumnMetaData :: Typed.TypedName Format.ColumnMetaData
columnMetaDataColumnMetaData = Typed.TypedName (Model.Name "hydra.ext.parquet.format.ColumnMetaData")

-- | DSL accessor for the dataPageOffset field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataDataPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64
columnMetaDataDataPageOffset x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "dataPageOffset")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the dictionaryPageOffset field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataDictionaryPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64)
columnMetaDataDictionaryPageOffset x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the encodingStats field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataEncodingStats :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe [Format.PageEncodingStats])
columnMetaDataEncodingStats x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "encodingStats")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the encodings field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataEncodings :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm [Format.Encoding]
columnMetaDataEncodings x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "encodings")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the indexPageOffset field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataIndexPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64)
columnMetaDataIndexPageOffset x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "indexPageOffset")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the keyValueMetadata field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataKeyValueMetadata :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe [Format.KeyValue])
columnMetaDataKeyValueMetadata x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the numValues field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataNumValues :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64
columnMetaDataNumValues x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "numValues")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the pathInSchema field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataPathInSchema :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm [String]
columnMetaDataPathInSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "pathInSchema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the statistics field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataStatistics :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe Format.Statistics)
columnMetaDataStatistics x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "statistics")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the totalCompressedSize field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataTotalCompressedSize :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64
columnMetaDataTotalCompressedSize x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the totalUncompressedSize field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataTotalUncompressedSize :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64
columnMetaDataTotalUncompressedSize x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataType :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm Format.Type
columnMetaDataType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the bloomFilterOffset field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithBloomFilterOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithBloomFilterOffset original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the codec field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithCodec :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm Format.CompressionCodec -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithCodec original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the dataPageOffset field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithDataPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithDataPageOffset original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the dictionaryPageOffset field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithDictionaryPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithDictionaryPageOffset original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the encodingStats field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithEncodingStats :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe [Format.PageEncodingStats]) -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithEncodingStats original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the encodings field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithEncodings :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm [Format.Encoding] -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithEncodings original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the indexPageOffset field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithIndexPageOffset :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithIndexPageOffset original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the keyValueMetadata field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithKeyValueMetadata :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe [Format.KeyValue]) -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithKeyValueMetadata original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the numValues field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithNumValues :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithNumValues original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the pathInSchema field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithPathInSchema :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm [String] -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithPathInSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the statistics field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithStatistics :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithStatistics original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the totalCompressedSize field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithTotalCompressedSize :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithTotalCompressedSize original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the totalUncompressedSize field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithTotalUncompressedSize :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithTotalUncompressedSize original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        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.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.parquet.format.ColumnMetaData
columnMetaDataWithType :: Typed.TypedTerm Format.ColumnMetaData -> Typed.TypedTerm Format.Type -> Typed.TypedTerm Format.ColumnMetaData
columnMetaDataWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "encodings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codec"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "codec")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalUncompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalUncompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dataPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "indexPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "dictionaryPageOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encodingStats"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "encodingStats")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "bloomFilterOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnMetaData"),
              Model.projectionFieldName = (Model.Name "bloomFilterOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.parquet.format.ColumnOrder
columnOrderColumnOrder :: Typed.TypedName Format.ColumnOrder
columnOrderColumnOrder = Typed.TypedName (Model.Name "hydra.ext.parquet.format.ColumnOrder")

-- | DSL injection for the typeOrder variant of hydra.ext.parquet.format.ColumnOrder
columnOrderTypeOrder :: Typed.TypedTerm Format.ColumnOrder
columnOrderTypeOrder =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.ColumnOrder"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typeOrder"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the brotli variant of hydra.ext.parquet.format.CompressionCodec
compressionCodecBrotli :: Typed.TypedTerm Format.CompressionCodec
compressionCodecBrotli =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "brotli"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.parquet.format.CompressionCodec
compressionCodecCompressionCodec :: Typed.TypedName Format.CompressionCodec
compressionCodecCompressionCodec = Typed.TypedName (Model.Name "hydra.ext.parquet.format.CompressionCodec")

-- | DSL injection for the gzip variant of hydra.ext.parquet.format.CompressionCodec
compressionCodecGzip :: Typed.TypedTerm Format.CompressionCodec
compressionCodecGzip =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "gzip"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the lz4Raw variant of hydra.ext.parquet.format.CompressionCodec
compressionCodecLz4Raw :: Typed.TypedTerm Format.CompressionCodec
compressionCodecLz4Raw =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lz4Raw"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the lzo variant of hydra.ext.parquet.format.CompressionCodec
compressionCodecLzo :: Typed.TypedTerm Format.CompressionCodec
compressionCodecLzo =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lzo"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the snappy variant of hydra.ext.parquet.format.CompressionCodec
compressionCodecSnappy :: Typed.TypedTerm Format.CompressionCodec
compressionCodecSnappy =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "snappy"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the uncompressed variant of hydra.ext.parquet.format.CompressionCodec
compressionCodecUncompressed :: Typed.TypedTerm Format.CompressionCodec
compressionCodecUncompressed =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uncompressed"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the zstd variant of hydra.ext.parquet.format.CompressionCodec
compressionCodecZstd :: Typed.TypedTerm Format.CompressionCodec
compressionCodecZstd =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.CompressionCodec"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "zstd"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.parquet.format.DataPageHeader
dataPageHeader :: Typed.TypedTerm Int -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm Format.DataPageHeader
dataPageHeader numValues encoding definitionLevelEncoding repetitionLevelEncoding statistics =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Typed.unTypedTerm numValues)},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Typed.unTypedTerm encoding)},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelEncoding"),
          Model.fieldTerm = (Typed.unTypedTerm definitionLevelEncoding)},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelEncoding"),
          Model.fieldTerm = (Typed.unTypedTerm repetitionLevelEncoding)},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Typed.unTypedTerm statistics)}]}))

-- | DSL name token for hydra.ext.parquet.format.DataPageHeader
dataPageHeaderDataPageHeader :: Typed.TypedName Format.DataPageHeader
dataPageHeaderDataPageHeader = Typed.TypedName (Model.Name "hydra.ext.parquet.format.DataPageHeader")

-- | DSL accessor for the definitionLevelEncoding field of hydra.ext.parquet.format.DataPageHeader
dataPageHeaderDefinitionLevelEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding
dataPageHeaderDefinitionLevelEncoding x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
        Model.projectionFieldName = (Model.Name "definitionLevelEncoding")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the encoding field of hydra.ext.parquet.format.DataPageHeader
dataPageHeaderEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding
dataPageHeaderEncoding x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
        Model.projectionFieldName = (Model.Name "encoding")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the numValues field of hydra.ext.parquet.format.DataPageHeader
dataPageHeaderNumValues :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Int
dataPageHeaderNumValues x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
        Model.projectionFieldName = (Model.Name "numValues")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the repetitionLevelEncoding field of hydra.ext.parquet.format.DataPageHeader
dataPageHeaderRepetitionLevelEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding
dataPageHeaderRepetitionLevelEncoding x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
        Model.projectionFieldName = (Model.Name "repetitionLevelEncoding")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the statistics field of hydra.ext.parquet.format.DataPageHeader
dataPageHeaderStatistics :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm (Maybe Format.Statistics)
dataPageHeaderStatistics x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
        Model.projectionFieldName = (Model.Name "statistics")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2 :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm Format.DataPageHeaderV2
dataPageHeaderV2 numValues numNulls numRows encoding definitionLevelsByteLength repetitionLevelsByteLength isCompressed statistics =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Typed.unTypedTerm numValues)},
        Model.Field {
          Model.fieldName = (Model.Name "numNulls"),
          Model.fieldTerm = (Typed.unTypedTerm numNulls)},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Typed.unTypedTerm numRows)},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Typed.unTypedTerm encoding)},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelsByteLength"),
          Model.fieldTerm = (Typed.unTypedTerm definitionLevelsByteLength)},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelsByteLength"),
          Model.fieldTerm = (Typed.unTypedTerm repetitionLevelsByteLength)},
        Model.Field {
          Model.fieldName = (Model.Name "isCompressed"),
          Model.fieldTerm = (Typed.unTypedTerm isCompressed)},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Typed.unTypedTerm statistics)}]}))

-- | DSL name token for hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2DataPageHeaderV2 :: Typed.TypedName Format.DataPageHeaderV2
dataPageHeaderV2DataPageHeaderV2 = Typed.TypedName (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2")

-- | DSL accessor for the definitionLevelsByteLength field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2DefinitionLevelsByteLength :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int
dataPageHeaderV2DefinitionLevelsByteLength x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
        Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the encoding field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2Encoding :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Format.Encoding
dataPageHeaderV2Encoding x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
        Model.projectionFieldName = (Model.Name "encoding")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the isCompressed field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2IsCompressed :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm (Maybe Bool)
dataPageHeaderV2IsCompressed x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
        Model.projectionFieldName = (Model.Name "isCompressed")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the numNulls field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2NumNulls :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int
dataPageHeaderV2NumNulls x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
        Model.projectionFieldName = (Model.Name "numNulls")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the numRows field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2NumRows :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int
dataPageHeaderV2NumRows x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
        Model.projectionFieldName = (Model.Name "numRows")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the numValues field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2NumValues :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int
dataPageHeaderV2NumValues x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
        Model.projectionFieldName = (Model.Name "numValues")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the repetitionLevelsByteLength field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2RepetitionLevelsByteLength :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int
dataPageHeaderV2RepetitionLevelsByteLength x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
        Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the statistics field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2Statistics :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm (Maybe Format.Statistics)
dataPageHeaderV2Statistics x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
        Model.projectionFieldName = (Model.Name "statistics")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the definitionLevelsByteLength field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2WithDefinitionLevelsByteLength :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeaderV2
dataPageHeaderV2WithDefinitionLevelsByteLength original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numNulls"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numNulls")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelsByteLength"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isCompressed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "isCompressed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the encoding field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2WithEncoding :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.DataPageHeaderV2
dataPageHeaderV2WithEncoding original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numNulls"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numNulls")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isCompressed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "isCompressed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the isCompressed field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2WithIsCompressed :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.DataPageHeaderV2
dataPageHeaderV2WithIsCompressed original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numNulls"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numNulls")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isCompressed"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the numNulls field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2WithNumNulls :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeaderV2
dataPageHeaderV2WithNumNulls original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numNulls"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isCompressed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "isCompressed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the numRows field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2WithNumRows :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeaderV2
dataPageHeaderV2WithNumRows original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numNulls"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numNulls")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isCompressed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "isCompressed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the numValues field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2WithNumValues :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeaderV2
dataPageHeaderV2WithNumValues original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "numNulls"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numNulls")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isCompressed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "isCompressed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the repetitionLevelsByteLength field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2WithRepetitionLevelsByteLength :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeaderV2
dataPageHeaderV2WithRepetitionLevelsByteLength original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numNulls"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numNulls")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelsByteLength"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "isCompressed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "isCompressed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the statistics field of hydra.ext.parquet.format.DataPageHeaderV2
dataPageHeaderV2WithStatistics :: Typed.TypedTerm Format.DataPageHeaderV2 -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm Format.DataPageHeaderV2
dataPageHeaderV2WithStatistics original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numNulls"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numNulls")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "definitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelsByteLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "repetitionLevelsByteLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isCompressed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeaderV2"),
              Model.projectionFieldName = (Model.Name "isCompressed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the definitionLevelEncoding field of hydra.ext.parquet.format.DataPageHeader
dataPageHeaderWithDefinitionLevelEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.DataPageHeader
dataPageHeaderWithDefinitionLevelEncoding original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelEncoding"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelEncoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "repetitionLevelEncoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the encoding field of hydra.ext.parquet.format.DataPageHeader
dataPageHeaderWithEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.DataPageHeader
dataPageHeaderWithEncoding original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelEncoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "definitionLevelEncoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelEncoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "repetitionLevelEncoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the numValues field of hydra.ext.parquet.format.DataPageHeader
dataPageHeaderWithNumValues :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DataPageHeader
dataPageHeaderWithNumValues original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelEncoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "definitionLevelEncoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelEncoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "repetitionLevelEncoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the repetitionLevelEncoding field of hydra.ext.parquet.format.DataPageHeader
dataPageHeaderWithRepetitionLevelEncoding :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.DataPageHeader
dataPageHeaderWithRepetitionLevelEncoding original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelEncoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "definitionLevelEncoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelEncoding"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "statistics")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the statistics field of hydra.ext.parquet.format.DataPageHeader
dataPageHeaderWithStatistics :: Typed.TypedTerm Format.DataPageHeader -> Typed.TypedTerm (Maybe Format.Statistics) -> Typed.TypedTerm Format.DataPageHeader
dataPageHeaderWithStatistics original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "definitionLevelEncoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "definitionLevelEncoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionLevelEncoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DataPageHeader"),
              Model.projectionFieldName = (Model.Name "repetitionLevelEncoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statistics"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

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

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

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

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

-- | DSL updater for the precision field of hydra.ext.parquet.format.DecimalType
decimalTypeWithPrecision :: Typed.TypedTerm Format.DecimalType -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DecimalType
decimalTypeWithPrecision original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DecimalType"),
      Model.recordFields = [
        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.parquet.format.DecimalType"),
              Model.projectionFieldName = (Model.Name "scale")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "precision"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the scale field of hydra.ext.parquet.format.DecimalType
decimalTypeWithScale :: Typed.TypedTerm Format.DecimalType -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DecimalType
decimalTypeWithScale original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DecimalType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "scale"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        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.parquet.format.DecimalType"),
              Model.projectionFieldName = (Model.Name "precision")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.parquet.format.DictionaryPageHeader
dictionaryPageHeader :: Typed.TypedTerm Int -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.DictionaryPageHeader
dictionaryPageHeader numValues encoding isSorted =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Typed.unTypedTerm numValues)},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Typed.unTypedTerm encoding)},
        Model.Field {
          Model.fieldName = (Model.Name "isSorted"),
          Model.fieldTerm = (Typed.unTypedTerm isSorted)}]}))

-- | DSL name token for hydra.ext.parquet.format.DictionaryPageHeader
dictionaryPageHeaderDictionaryPageHeader :: Typed.TypedName Format.DictionaryPageHeader
dictionaryPageHeaderDictionaryPageHeader = Typed.TypedName (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader")

-- | DSL accessor for the encoding field of hydra.ext.parquet.format.DictionaryPageHeader
dictionaryPageHeaderEncoding :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm Format.Encoding
dictionaryPageHeaderEncoding x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
        Model.projectionFieldName = (Model.Name "encoding")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the isSorted field of hydra.ext.parquet.format.DictionaryPageHeader
dictionaryPageHeaderIsSorted :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm (Maybe Bool)
dictionaryPageHeaderIsSorted x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
        Model.projectionFieldName = (Model.Name "isSorted")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the numValues field of hydra.ext.parquet.format.DictionaryPageHeader
dictionaryPageHeaderNumValues :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm Int
dictionaryPageHeaderNumValues x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
        Model.projectionFieldName = (Model.Name "numValues")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the encoding field of hydra.ext.parquet.format.DictionaryPageHeader
dictionaryPageHeaderWithEncoding :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.DictionaryPageHeader
dictionaryPageHeaderWithEncoding original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "isSorted"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
              Model.projectionFieldName = (Model.Name "isSorted")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the isSorted field of hydra.ext.parquet.format.DictionaryPageHeader
dictionaryPageHeaderWithIsSorted :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Format.DictionaryPageHeader
dictionaryPageHeaderWithIsSorted original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
              Model.projectionFieldName = (Model.Name "numValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isSorted"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the numValues field of hydra.ext.parquet.format.DictionaryPageHeader
dictionaryPageHeaderWithNumValues :: Typed.TypedTerm Format.DictionaryPageHeader -> Typed.TypedTerm Int -> Typed.TypedTerm Format.DictionaryPageHeader
dictionaryPageHeaderWithNumValues original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "numValues"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isSorted"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.DictionaryPageHeader"),
              Model.projectionFieldName = (Model.Name "isSorted")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the bitPacked variant of hydra.ext.parquet.format.Encoding
encodingBitPacked :: Typed.TypedTerm Format.Encoding
encodingBitPacked =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitPacked"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the byteStreamSplit variant of hydra.ext.parquet.format.Encoding
encodingByteStreamSplit :: Typed.TypedTerm Format.Encoding
encodingByteStreamSplit =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "byteStreamSplit"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the deltaBinaryPacked variant of hydra.ext.parquet.format.Encoding
encodingDeltaBinaryPacked :: Typed.TypedTerm Format.Encoding
encodingDeltaBinaryPacked =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "deltaBinaryPacked"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the deltaByteArray variant of hydra.ext.parquet.format.Encoding
encodingDeltaByteArray :: Typed.TypedTerm Format.Encoding
encodingDeltaByteArray =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "deltaByteArray"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the deltaLengthByteArray variant of hydra.ext.parquet.format.Encoding
encodingDeltaLengthByteArray :: Typed.TypedTerm Format.Encoding
encodingDeltaLengthByteArray =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "deltaLengthByteArray"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.parquet.format.Encoding
encodingEncoding :: Typed.TypedName Format.Encoding
encodingEncoding = Typed.TypedName (Model.Name "hydra.ext.parquet.format.Encoding")

-- | DSL injection for the plain variant of hydra.ext.parquet.format.Encoding
encodingPlain :: Typed.TypedTerm Format.Encoding
encodingPlain =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "plain"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the rle variant of hydra.ext.parquet.format.Encoding
encodingRle :: Typed.TypedTerm Format.Encoding
encodingRle =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rle"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the rleDictionary variant of hydra.ext.parquet.format.Encoding
encodingRleDictionary :: Typed.TypedTerm Format.Encoding
encodingRleDictionary =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Encoding"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rleDictionary"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the aesGcmCtrV1 variant of hydra.ext.parquet.format.EncryptionAlgorithm
encryptionAlgorithmAesGcmCtrV1 :: Typed.TypedTerm Format.AesGcmCtrV1 -> Typed.TypedTerm Format.EncryptionAlgorithm
encryptionAlgorithmAesGcmCtrV1 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionAlgorithm"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "aesGcmCtrV1"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the aesGcmV1 variant of hydra.ext.parquet.format.EncryptionAlgorithm
encryptionAlgorithmAesGcmV1 :: Typed.TypedTerm Format.AesGcmV1 -> Typed.TypedTerm Format.EncryptionAlgorithm
encryptionAlgorithmAesGcmV1 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionAlgorithm"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "aesGcmV1"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.parquet.format.EncryptionAlgorithm
encryptionAlgorithmEncryptionAlgorithm :: Typed.TypedName Format.EncryptionAlgorithm
encryptionAlgorithmEncryptionAlgorithm = Typed.TypedName (Model.Name "hydra.ext.parquet.format.EncryptionAlgorithm")

-- | DSL constructor for hydra.ext.parquet.format.EncryptionWithColumnKey
encryptionWithColumnKey :: Typed.TypedTerm [String] -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.EncryptionWithColumnKey
encryptionWithColumnKey pathInSchema keyMetadata =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Typed.unTypedTerm pathInSchema)},
        Model.Field {
          Model.fieldName = (Model.Name "keyMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm keyMetadata)}]}))

-- | DSL name token for hydra.ext.parquet.format.EncryptionWithColumnKey
encryptionWithColumnKeyEncryptionWithColumnKey :: Typed.TypedName Format.EncryptionWithColumnKey
encryptionWithColumnKeyEncryptionWithColumnKey =
    Typed.TypedName (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey")

-- | DSL accessor for the keyMetadata field of hydra.ext.parquet.format.EncryptionWithColumnKey
encryptionWithColumnKeyKeyMetadata :: Typed.TypedTerm Format.EncryptionWithColumnKey -> Typed.TypedTerm (Maybe B.ByteString)
encryptionWithColumnKeyKeyMetadata x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"),
        Model.projectionFieldName = (Model.Name "keyMetadata")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the pathInSchema field of hydra.ext.parquet.format.EncryptionWithColumnKey
encryptionWithColumnKeyPathInSchema :: Typed.TypedTerm Format.EncryptionWithColumnKey -> Typed.TypedTerm [String]
encryptionWithColumnKeyPathInSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"),
        Model.projectionFieldName = (Model.Name "pathInSchema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the keyMetadata field of hydra.ext.parquet.format.EncryptionWithColumnKey
encryptionWithColumnKeyWithKeyMetadata :: Typed.TypedTerm Format.EncryptionWithColumnKey -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.EncryptionWithColumnKey
encryptionWithColumnKeyWithKeyMetadata original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"),
              Model.projectionFieldName = (Model.Name "pathInSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the pathInSchema field of hydra.ext.parquet.format.EncryptionWithColumnKey
encryptionWithColumnKeyWithPathInSchema :: Typed.TypedTerm Format.EncryptionWithColumnKey -> Typed.TypedTerm [String] -> Typed.TypedTerm Format.EncryptionWithColumnKey
encryptionWithColumnKeyWithPathInSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pathInSchema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "keyMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.EncryptionWithColumnKey"),
              Model.projectionFieldName = (Model.Name "keyMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.parquet.format.FieldRepetitionType
fieldRepetitionTypeFieldRepetitionType :: Typed.TypedName Format.FieldRepetitionType
fieldRepetitionTypeFieldRepetitionType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.FieldRepetitionType")

-- | DSL injection for the optional variant of hydra.ext.parquet.format.FieldRepetitionType
fieldRepetitionTypeOptional :: Typed.TypedTerm Format.FieldRepetitionType
fieldRepetitionTypeOptional =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.FieldRepetitionType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "optional"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the repeated variant of hydra.ext.parquet.format.FieldRepetitionType
fieldRepetitionTypeRepeated :: Typed.TypedTerm Format.FieldRepetitionType
fieldRepetitionTypeRepeated =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.FieldRepetitionType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "repeated"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the required variant of hydra.ext.parquet.format.FieldRepetitionType
fieldRepetitionTypeRequired :: Typed.TypedTerm Format.FieldRepetitionType
fieldRepetitionTypeRequired =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.FieldRepetitionType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "required"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.parquet.format.FileCryptoMetaData
fileCryptoMetaData :: Typed.TypedTerm Format.EncryptionAlgorithm -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.FileCryptoMetaData
fileCryptoMetaData encryptionAlgorithm keyMetadata =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Typed.unTypedTerm encryptionAlgorithm)},
        Model.Field {
          Model.fieldName = (Model.Name "keyMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm keyMetadata)}]}))

-- | DSL accessor for the encryptionAlgorithm field of hydra.ext.parquet.format.FileCryptoMetaData
fileCryptoMetaDataEncryptionAlgorithm :: Typed.TypedTerm Format.FileCryptoMetaData -> Typed.TypedTerm Format.EncryptionAlgorithm
fileCryptoMetaDataEncryptionAlgorithm x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"),
        Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.FileCryptoMetaData
fileCryptoMetaDataFileCryptoMetaData :: Typed.TypedName Format.FileCryptoMetaData
fileCryptoMetaDataFileCryptoMetaData = Typed.TypedName (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData")

-- | DSL accessor for the keyMetadata field of hydra.ext.parquet.format.FileCryptoMetaData
fileCryptoMetaDataKeyMetadata :: Typed.TypedTerm Format.FileCryptoMetaData -> Typed.TypedTerm (Maybe B.ByteString)
fileCryptoMetaDataKeyMetadata x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"),
        Model.projectionFieldName = (Model.Name "keyMetadata")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the encryptionAlgorithm field of hydra.ext.parquet.format.FileCryptoMetaData
fileCryptoMetaDataWithEncryptionAlgorithm :: Typed.TypedTerm Format.FileCryptoMetaData -> Typed.TypedTerm Format.EncryptionAlgorithm -> Typed.TypedTerm Format.FileCryptoMetaData
fileCryptoMetaDataWithEncryptionAlgorithm original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "keyMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"),
              Model.projectionFieldName = (Model.Name "keyMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the keyMetadata field of hydra.ext.parquet.format.FileCryptoMetaData
fileCryptoMetaDataWithKeyMetadata :: Typed.TypedTerm Format.FileCryptoMetaData -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.FileCryptoMetaData
fileCryptoMetaDataWithKeyMetadata original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileCryptoMetaData"),
              Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.parquet.format.FileMetaData
fileMetaData :: Typed.TypedTerm Int -> Typed.TypedTerm [Format.SchemaElement] -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm [Format.RowGroup] -> Typed.TypedTerm (Maybe [Format.KeyValue]) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe [Format.ColumnOrder]) -> Typed.TypedTerm (Maybe Format.EncryptionAlgorithm) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.FileMetaData
fileMetaData version schema numRows rowGroups keyValueMetadata createdBy columnOrders encryptionAlgorithm footerSigningKeyMetadata =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Typed.unTypedTerm version)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Typed.unTypedTerm numRows)},
        Model.Field {
          Model.fieldName = (Model.Name "rowGroups"),
          Model.fieldTerm = (Typed.unTypedTerm rowGroups)},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm keyValueMetadata)},
        Model.Field {
          Model.fieldName = (Model.Name "createdBy"),
          Model.fieldTerm = (Typed.unTypedTerm createdBy)},
        Model.Field {
          Model.fieldName = (Model.Name "columnOrders"),
          Model.fieldTerm = (Typed.unTypedTerm columnOrders)},
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Typed.unTypedTerm encryptionAlgorithm)},
        Model.Field {
          Model.fieldName = (Model.Name "footerSigningKeyMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm footerSigningKeyMetadata)}]}))

-- | DSL accessor for the columnOrders field of hydra.ext.parquet.format.FileMetaData
fileMetaDataColumnOrders :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe [Format.ColumnOrder])
fileMetaDataColumnOrders x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
        Model.projectionFieldName = (Model.Name "columnOrders")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the createdBy field of hydra.ext.parquet.format.FileMetaData
fileMetaDataCreatedBy :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe String)
fileMetaDataCreatedBy x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
        Model.projectionFieldName = (Model.Name "createdBy")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the encryptionAlgorithm field of hydra.ext.parquet.format.FileMetaData
fileMetaDataEncryptionAlgorithm :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe Format.EncryptionAlgorithm)
fileMetaDataEncryptionAlgorithm x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
        Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.FileMetaData
fileMetaDataFileMetaData :: Typed.TypedName Format.FileMetaData
fileMetaDataFileMetaData = Typed.TypedName (Model.Name "hydra.ext.parquet.format.FileMetaData")

-- | DSL accessor for the footerSigningKeyMetadata field of hydra.ext.parquet.format.FileMetaData
fileMetaDataFooterSigningKeyMetadata :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe B.ByteString)
fileMetaDataFooterSigningKeyMetadata x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
        Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the keyValueMetadata field of hydra.ext.parquet.format.FileMetaData
fileMetaDataKeyValueMetadata :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe [Format.KeyValue])
fileMetaDataKeyValueMetadata x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
        Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the numRows field of hydra.ext.parquet.format.FileMetaData
fileMetaDataNumRows :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm I.Int64
fileMetaDataNumRows x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
        Model.projectionFieldName = (Model.Name "numRows")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the rowGroups field of hydra.ext.parquet.format.FileMetaData
fileMetaDataRowGroups :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm [Format.RowGroup]
fileMetaDataRowGroups x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
        Model.projectionFieldName = (Model.Name "rowGroups")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the schema field of hydra.ext.parquet.format.FileMetaData
fileMetaDataSchema :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm [Format.SchemaElement]
fileMetaDataSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
        Model.projectionFieldName = (Model.Name "schema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the version field of hydra.ext.parquet.format.FileMetaData
fileMetaDataVersion :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm Int
fileMetaDataVersion x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
        Model.projectionFieldName = (Model.Name "version")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the columnOrders field of hydra.ext.parquet.format.FileMetaData
fileMetaDataWithColumnOrders :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe [Format.ColumnOrder]) -> Typed.TypedTerm Format.FileMetaData
fileMetaDataWithColumnOrders original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rowGroups"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "rowGroups")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "createdBy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "createdBy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnOrders"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "footerSigningKeyMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the createdBy field of hydra.ext.parquet.format.FileMetaData
fileMetaDataWithCreatedBy :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.FileMetaData
fileMetaDataWithCreatedBy original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rowGroups"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "rowGroups")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "createdBy"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "columnOrders"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "columnOrders")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "footerSigningKeyMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the encryptionAlgorithm field of hydra.ext.parquet.format.FileMetaData
fileMetaDataWithEncryptionAlgorithm :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe Format.EncryptionAlgorithm) -> Typed.TypedTerm Format.FileMetaData
fileMetaDataWithEncryptionAlgorithm original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rowGroups"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "rowGroups")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "createdBy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "createdBy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnOrders"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "columnOrders")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "footerSigningKeyMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the footerSigningKeyMetadata field of hydra.ext.parquet.format.FileMetaData
fileMetaDataWithFooterSigningKeyMetadata :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.FileMetaData
fileMetaDataWithFooterSigningKeyMetadata original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rowGroups"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "rowGroups")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "createdBy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "createdBy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnOrders"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "columnOrders")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "footerSigningKeyMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the keyValueMetadata field of hydra.ext.parquet.format.FileMetaData
fileMetaDataWithKeyValueMetadata :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm (Maybe [Format.KeyValue]) -> Typed.TypedTerm Format.FileMetaData
fileMetaDataWithKeyValueMetadata original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rowGroups"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "rowGroups")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "createdBy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "createdBy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnOrders"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "columnOrders")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "footerSigningKeyMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the numRows field of hydra.ext.parquet.format.FileMetaData
fileMetaDataWithNumRows :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.FileMetaData
fileMetaDataWithNumRows original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "rowGroups"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "rowGroups")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "createdBy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "createdBy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnOrders"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "columnOrders")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "footerSigningKeyMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the rowGroups field of hydra.ext.parquet.format.FileMetaData
fileMetaDataWithRowGroups :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm [Format.RowGroup] -> Typed.TypedTerm Format.FileMetaData
fileMetaDataWithRowGroups original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rowGroups"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "createdBy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "createdBy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnOrders"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "columnOrders")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "footerSigningKeyMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.parquet.format.FileMetaData
fileMetaDataWithSchema :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm [Format.SchemaElement] -> Typed.TypedTerm Format.FileMetaData
fileMetaDataWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rowGroups"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "rowGroups")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "createdBy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "createdBy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnOrders"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "columnOrders")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "footerSigningKeyMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the version field of hydra.ext.parquet.format.FileMetaData
fileMetaDataWithVersion :: Typed.TypedTerm Format.FileMetaData -> Typed.TypedTerm Int -> Typed.TypedTerm Format.FileMetaData
fileMetaDataWithVersion original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rowGroups"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "rowGroups")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "keyValueMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "keyValueMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "createdBy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "createdBy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "columnOrders"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "columnOrders")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encryptionAlgorithm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "encryptionAlgorithm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "footerSigningKeyMetadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.FileMetaData"),
              Model.projectionFieldName = (Model.Name "footerSigningKeyMetadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.parquet.format.IntType
intType :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.IntType
intType bitWidth isSigned =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.IntType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "bitWidth"),
          Model.fieldTerm = (Typed.unTypedTerm bitWidth)},
        Model.Field {
          Model.fieldName = (Model.Name "isSigned"),
          Model.fieldTerm = (Typed.unTypedTerm isSigned)}]}))

-- | DSL accessor for the bitWidth field of hydra.ext.parquet.format.IntType
intTypeBitWidth :: Typed.TypedTerm Format.IntType -> Typed.TypedTerm I.Int16
intTypeBitWidth x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.IntType"),
        Model.projectionFieldName = (Model.Name "bitWidth")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.IntType
intTypeIntType :: Typed.TypedName Format.IntType
intTypeIntType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.IntType")

-- | DSL accessor for the isSigned field of hydra.ext.parquet.format.IntType
intTypeIsSigned :: Typed.TypedTerm Format.IntType -> Typed.TypedTerm Bool
intTypeIsSigned x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.IntType"),
        Model.projectionFieldName = (Model.Name "isSigned")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the bitWidth field of hydra.ext.parquet.format.IntType
intTypeWithBitWidth :: Typed.TypedTerm Format.IntType -> Typed.TypedTerm I.Int16 -> Typed.TypedTerm Format.IntType
intTypeWithBitWidth original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.IntType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "bitWidth"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "isSigned"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.IntType"),
              Model.projectionFieldName = (Model.Name "isSigned")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the isSigned field of hydra.ext.parquet.format.IntType
intTypeWithIsSigned :: Typed.TypedTerm Format.IntType -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.IntType
intTypeWithIsSigned original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.IntType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "bitWidth"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.IntType"),
              Model.projectionFieldName = (Model.Name "bitWidth")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isSigned"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.parquet.format.KeyValue
keyValue :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.KeyValue
keyValue key value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "key"),
          Model.fieldTerm = (Typed.unTypedTerm key)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)}]}))

-- | DSL accessor for the key field of hydra.ext.parquet.format.KeyValue
keyValueKey :: Typed.TypedTerm Format.KeyValue -> Typed.TypedTerm String
keyValueKey x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"),
        Model.projectionFieldName = (Model.Name "key")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.KeyValue
keyValueKeyValue :: Typed.TypedName Format.KeyValue
keyValueKeyValue = Typed.TypedName (Model.Name "hydra.ext.parquet.format.KeyValue")

-- | DSL accessor for the value field of hydra.ext.parquet.format.KeyValue
keyValueValue :: Typed.TypedTerm Format.KeyValue -> Typed.TypedTerm (Maybe String)
keyValueValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the key field of hydra.ext.parquet.format.KeyValue
keyValueWithKey :: Typed.TypedTerm Format.KeyValue -> Typed.TypedTerm String -> Typed.TypedTerm Format.KeyValue
keyValueWithKey original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "key"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.ext.parquet.format.KeyValue
keyValueWithValue :: Typed.TypedTerm Format.KeyValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.KeyValue
keyValueWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "key"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.KeyValue"),
              Model.projectionFieldName = (Model.Name "key")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the bson variant of hydra.ext.parquet.format.LogicalType
logicalTypeBson :: Typed.TypedTerm Format.LogicalType
logicalTypeBson =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bson"),
        Model.fieldTerm = Model.TermUnit}}))

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

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

-- | DSL injection for the enum variant of hydra.ext.parquet.format.LogicalType
logicalTypeEnum :: Typed.TypedTerm Format.LogicalType
logicalTypeEnum =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "enum"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the integer variant of hydra.ext.parquet.format.LogicalType
logicalTypeInteger :: Typed.TypedTerm Format.IntType -> Typed.TypedTerm Format.LogicalType
logicalTypeInteger x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "integer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the json variant of hydra.ext.parquet.format.LogicalType
logicalTypeJson :: Typed.TypedTerm Format.LogicalType
logicalTypeJson =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "json"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the list variant of hydra.ext.parquet.format.LogicalType
logicalTypeList :: Typed.TypedTerm Format.LogicalType
logicalTypeList =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "list"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.parquet.format.LogicalType
logicalTypeLogicalType :: Typed.TypedName Format.LogicalType
logicalTypeLogicalType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.LogicalType")

-- | DSL injection for the map variant of hydra.ext.parquet.format.LogicalType
logicalTypeMap :: Typed.TypedTerm Format.LogicalType
logicalTypeMap =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "map"),
        Model.fieldTerm = Model.TermUnit}}))

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

-- | DSL injection for the time variant of hydra.ext.parquet.format.LogicalType
logicalTypeTime :: Typed.TypedTerm Format.TimeType -> Typed.TypedTerm Format.LogicalType
logicalTypeTime x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "time"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the timestamp variant of hydra.ext.parquet.format.LogicalType
logicalTypeTimestamp :: Typed.TypedTerm Format.TimestampType -> Typed.TypedTerm Format.LogicalType
logicalTypeTimestamp x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "timestamp"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the unknown variant of hydra.ext.parquet.format.LogicalType
logicalTypeUnknown :: Typed.TypedTerm Format.LogicalType
logicalTypeUnknown =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unknown"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the uuid variant of hydra.ext.parquet.format.LogicalType
logicalTypeUuid :: Typed.TypedTerm Format.LogicalType
logicalTypeUuid =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.LogicalType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uuid"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.parquet.format.OffsetIndex
offsetIndex :: Typed.TypedTerm [Format.PageLocation] -> Typed.TypedTerm Format.OffsetIndex
offsetIndex pageLocations =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.OffsetIndex"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pageLocations"),
          Model.fieldTerm = (Typed.unTypedTerm pageLocations)}]}))

-- | DSL name token for hydra.ext.parquet.format.OffsetIndex
offsetIndexOffsetIndex :: Typed.TypedName Format.OffsetIndex
offsetIndexOffsetIndex = Typed.TypedName (Model.Name "hydra.ext.parquet.format.OffsetIndex")

-- | DSL accessor for the pageLocations field of hydra.ext.parquet.format.OffsetIndex
offsetIndexPageLocations :: Typed.TypedTerm Format.OffsetIndex -> Typed.TypedTerm [Format.PageLocation]
offsetIndexPageLocations x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.OffsetIndex"),
        Model.projectionFieldName = (Model.Name "pageLocations")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the pageLocations field of hydra.ext.parquet.format.OffsetIndex
offsetIndexWithPageLocations :: Typed.TypedTerm Format.OffsetIndex -> Typed.TypedTerm [Format.PageLocation] -> Typed.TypedTerm Format.OffsetIndex
offsetIndexWithPageLocations original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.OffsetIndex"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pageLocations"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.parquet.format.PageEncodingStats
pageEncodingStats :: Typed.TypedTerm Format.PageType -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PageEncodingStats
pageEncodingStats pageType encoding count =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pageType"),
          Model.fieldTerm = (Typed.unTypedTerm pageType)},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Typed.unTypedTerm encoding)},
        Model.Field {
          Model.fieldName = (Model.Name "count"),
          Model.fieldTerm = (Typed.unTypedTerm count)}]}))

-- | DSL accessor for the count field of hydra.ext.parquet.format.PageEncodingStats
pageEncodingStatsCount :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Int
pageEncodingStatsCount x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
        Model.projectionFieldName = (Model.Name "count")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the encoding field of hydra.ext.parquet.format.PageEncodingStats
pageEncodingStatsEncoding :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Format.Encoding
pageEncodingStatsEncoding x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
        Model.projectionFieldName = (Model.Name "encoding")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.PageEncodingStats
pageEncodingStatsPageEncodingStats :: Typed.TypedName Format.PageEncodingStats
pageEncodingStatsPageEncodingStats = Typed.TypedName (Model.Name "hydra.ext.parquet.format.PageEncodingStats")

-- | DSL accessor for the pageType field of hydra.ext.parquet.format.PageEncodingStats
pageEncodingStatsPageType :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Format.PageType
pageEncodingStatsPageType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
        Model.projectionFieldName = (Model.Name "pageType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the count field of hydra.ext.parquet.format.PageEncodingStats
pageEncodingStatsWithCount :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PageEncodingStats
pageEncodingStatsWithCount original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pageType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
              Model.projectionFieldName = (Model.Name "pageType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "count"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the encoding field of hydra.ext.parquet.format.PageEncodingStats
pageEncodingStatsWithEncoding :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Format.Encoding -> Typed.TypedTerm Format.PageEncodingStats
pageEncodingStatsWithEncoding original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pageType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
              Model.projectionFieldName = (Model.Name "pageType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "count"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
              Model.projectionFieldName = (Model.Name "count")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the pageType field of hydra.ext.parquet.format.PageEncodingStats
pageEncodingStatsWithPageType :: Typed.TypedTerm Format.PageEncodingStats -> Typed.TypedTerm Format.PageType -> Typed.TypedTerm Format.PageEncodingStats
pageEncodingStatsWithPageType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pageType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "encoding"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
              Model.projectionFieldName = (Model.Name "encoding")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "count"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageEncodingStats"),
              Model.projectionFieldName = (Model.Name "count")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.parquet.format.PageHeader
pageHeader :: Typed.TypedTerm Format.PageType -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Format.DataPageHeader) -> Typed.TypedTerm (Maybe Format.IndexPageHeader) -> Typed.TypedTerm (Maybe Format.DictionaryPageHeader) -> Typed.TypedTerm (Maybe Format.DataPageHeaderV2) -> Typed.TypedTerm Format.PageHeader
pageHeader type_ uncompressedPageSize compressedPageSize crc dataPageHeader indexPageHeader dictionaryPageHeader dataPageHeaderV2 =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "uncompressedPageSize"),
          Model.fieldTerm = (Typed.unTypedTerm uncompressedPageSize)},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Typed.unTypedTerm compressedPageSize)},
        Model.Field {
          Model.fieldName = (Model.Name "crc"),
          Model.fieldTerm = (Typed.unTypedTerm crc)},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeader"),
          Model.fieldTerm = (Typed.unTypedTerm dataPageHeader)},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageHeader"),
          Model.fieldTerm = (Typed.unTypedTerm indexPageHeader)},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageHeader"),
          Model.fieldTerm = (Typed.unTypedTerm dictionaryPageHeader)},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeaderV2"),
          Model.fieldTerm = (Typed.unTypedTerm dataPageHeaderV2)}]}))

-- | DSL accessor for the compressedPageSize field of hydra.ext.parquet.format.PageHeader
pageHeaderCompressedPageSize :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Int
pageHeaderCompressedPageSize x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
        Model.projectionFieldName = (Model.Name "compressedPageSize")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the crc field of hydra.ext.parquet.format.PageHeader
pageHeaderCrc :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Int)
pageHeaderCrc x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
        Model.projectionFieldName = (Model.Name "crc")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the dataPageHeader field of hydra.ext.parquet.format.PageHeader
pageHeaderDataPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DataPageHeader)
pageHeaderDataPageHeader x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
        Model.projectionFieldName = (Model.Name "dataPageHeader")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the dataPageHeaderV2 field of hydra.ext.parquet.format.PageHeader
pageHeaderDataPageHeaderV2 :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DataPageHeaderV2)
pageHeaderDataPageHeaderV2 x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
        Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the dictionaryPageHeader field of hydra.ext.parquet.format.PageHeader
pageHeaderDictionaryPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DictionaryPageHeader)
pageHeaderDictionaryPageHeader x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
        Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the indexPageHeader field of hydra.ext.parquet.format.PageHeader
pageHeaderIndexPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.IndexPageHeader)
pageHeaderIndexPageHeader x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
        Model.projectionFieldName = (Model.Name "indexPageHeader")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.PageHeader
pageHeaderPageHeader :: Typed.TypedName Format.PageHeader
pageHeaderPageHeader = Typed.TypedName (Model.Name "hydra.ext.parquet.format.PageHeader")

-- | DSL accessor for the type field of hydra.ext.parquet.format.PageHeader
pageHeaderType :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Format.PageType
pageHeaderType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the uncompressedPageSize field of hydra.ext.parquet.format.PageHeader
pageHeaderUncompressedPageSize :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Int
pageHeaderUncompressedPageSize x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
        Model.projectionFieldName = (Model.Name "uncompressedPageSize")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the compressedPageSize field of hydra.ext.parquet.format.PageHeader
pageHeaderWithCompressedPageSize :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PageHeader
pageHeaderWithCompressedPageSize original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
      Model.recordFields = [
        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.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "uncompressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "uncompressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "crc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "crc")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "indexPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeaderV2"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the crc field of hydra.ext.parquet.format.PageHeader
pageHeaderWithCrc :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.PageHeader
pageHeaderWithCrc original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
      Model.recordFields = [
        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.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "uncompressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "uncompressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "compressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "crc"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "indexPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeaderV2"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the dataPageHeader field of hydra.ext.parquet.format.PageHeader
pageHeaderWithDataPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DataPageHeader) -> Typed.TypedTerm Format.PageHeader
pageHeaderWithDataPageHeader original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
      Model.recordFields = [
        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.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "uncompressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "uncompressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "compressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "crc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "crc")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeader"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "indexPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeaderV2"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the dataPageHeaderV2 field of hydra.ext.parquet.format.PageHeader
pageHeaderWithDataPageHeaderV2 :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DataPageHeaderV2) -> Typed.TypedTerm Format.PageHeader
pageHeaderWithDataPageHeaderV2 original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
      Model.recordFields = [
        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.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "uncompressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "uncompressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "compressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "crc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "crc")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "indexPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeaderV2"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the dictionaryPageHeader field of hydra.ext.parquet.format.PageHeader
pageHeaderWithDictionaryPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.DictionaryPageHeader) -> Typed.TypedTerm Format.PageHeader
pageHeaderWithDictionaryPageHeader original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
      Model.recordFields = [
        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.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "uncompressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "uncompressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "compressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "crc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "crc")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "indexPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageHeader"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeaderV2"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the indexPageHeader field of hydra.ext.parquet.format.PageHeader
pageHeaderWithIndexPageHeader :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm (Maybe Format.IndexPageHeader) -> Typed.TypedTerm Format.PageHeader
pageHeaderWithIndexPageHeader original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
      Model.recordFields = [
        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.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "uncompressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "uncompressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "compressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "crc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "crc")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageHeader"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeaderV2"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.parquet.format.PageHeader
pageHeaderWithType :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Format.PageType -> Typed.TypedTerm Format.PageHeader
pageHeaderWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "uncompressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "uncompressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "compressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "crc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "crc")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "indexPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeaderV2"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the uncompressedPageSize field of hydra.ext.parquet.format.PageHeader
pageHeaderWithUncompressedPageSize :: Typed.TypedTerm Format.PageHeader -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PageHeader
pageHeaderWithUncompressedPageSize original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
      Model.recordFields = [
        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.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "uncompressedPageSize"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "compressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "crc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "crc")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "indexPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "indexPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dictionaryPageHeader"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dictionaryPageHeader")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dataPageHeaderV2"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageHeader"),
              Model.projectionFieldName = (Model.Name "dataPageHeaderV2")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.parquet.format.PageLocation
pageLocation :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Int -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.PageLocation
pageLocation offset compressedPageSize firstRowIndex =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "offset"),
          Model.fieldTerm = (Typed.unTypedTerm offset)},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Typed.unTypedTerm compressedPageSize)},
        Model.Field {
          Model.fieldName = (Model.Name "firstRowIndex"),
          Model.fieldTerm = (Typed.unTypedTerm firstRowIndex)}]}))

-- | DSL accessor for the compressedPageSize field of hydra.ext.parquet.format.PageLocation
pageLocationCompressedPageSize :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm Int
pageLocationCompressedPageSize x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
        Model.projectionFieldName = (Model.Name "compressedPageSize")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the firstRowIndex field of hydra.ext.parquet.format.PageLocation
pageLocationFirstRowIndex :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm I.Int64
pageLocationFirstRowIndex x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
        Model.projectionFieldName = (Model.Name "firstRowIndex")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the offset field of hydra.ext.parquet.format.PageLocation
pageLocationOffset :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm I.Int64
pageLocationOffset x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
        Model.projectionFieldName = (Model.Name "offset")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.PageLocation
pageLocationPageLocation :: Typed.TypedName Format.PageLocation
pageLocationPageLocation = Typed.TypedName (Model.Name "hydra.ext.parquet.format.PageLocation")

-- | DSL updater for the compressedPageSize field of hydra.ext.parquet.format.PageLocation
pageLocationWithCompressedPageSize :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PageLocation
pageLocationWithCompressedPageSize original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "offset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
              Model.projectionFieldName = (Model.Name "offset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "firstRowIndex"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
              Model.projectionFieldName = (Model.Name "firstRowIndex")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the firstRowIndex field of hydra.ext.parquet.format.PageLocation
pageLocationWithFirstRowIndex :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.PageLocation
pageLocationWithFirstRowIndex original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "offset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
              Model.projectionFieldName = (Model.Name "offset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
              Model.projectionFieldName = (Model.Name "compressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "firstRowIndex"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the offset field of hydra.ext.parquet.format.PageLocation
pageLocationWithOffset :: Typed.TypedTerm Format.PageLocation -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.PageLocation
pageLocationWithOffset original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "offset"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "compressedPageSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
              Model.projectionFieldName = (Model.Name "compressedPageSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "firstRowIndex"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.PageLocation"),
              Model.projectionFieldName = (Model.Name "firstRowIndex")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the dataPage variant of hydra.ext.parquet.format.PageType
pageTypeDataPage :: Typed.TypedTerm Format.PageType
pageTypeDataPage =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.PageType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "dataPage"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the dataPageV2 variant of hydra.ext.parquet.format.PageType
pageTypeDataPageV2 :: Typed.TypedTerm Format.PageType
pageTypeDataPageV2 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.PageType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "dataPageV2"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the dictionaryPage variant of hydra.ext.parquet.format.PageType
pageTypeDictionaryPage :: Typed.TypedTerm Format.PageType
pageTypeDictionaryPage =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.PageType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "dictionaryPage"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the indexPage variant of hydra.ext.parquet.format.PageType
pageTypeIndexPage :: Typed.TypedTerm Format.PageType
pageTypeIndexPage =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.PageType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "indexPage"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.parquet.format.PageType
pageTypePageType :: Typed.TypedName Format.PageType
pageTypePageType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.PageType")

-- | DSL constructor for hydra.ext.parquet.format.RowGroup
rowGroup :: Typed.TypedTerm [Format.ColumnChunk] -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm (Maybe [Format.SortingColumn]) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm (Maybe I.Int16) -> Typed.TypedTerm Format.RowGroup
rowGroup columns totalByteSize numRows sortingColumns fileOffset totalCompressedSize ordinal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columns"),
          Model.fieldTerm = (Typed.unTypedTerm columns)},
        Model.Field {
          Model.fieldName = (Model.Name "totalByteSize"),
          Model.fieldTerm = (Typed.unTypedTerm totalByteSize)},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Typed.unTypedTerm numRows)},
        Model.Field {
          Model.fieldName = (Model.Name "sortingColumns"),
          Model.fieldTerm = (Typed.unTypedTerm sortingColumns)},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Typed.unTypedTerm fileOffset)},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Typed.unTypedTerm totalCompressedSize)},
        Model.Field {
          Model.fieldName = (Model.Name "ordinal"),
          Model.fieldTerm = (Typed.unTypedTerm ordinal)}]}))

-- | DSL accessor for the columns field of hydra.ext.parquet.format.RowGroup
rowGroupColumns :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm [Format.ColumnChunk]
rowGroupColumns x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
        Model.projectionFieldName = (Model.Name "columns")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the fileOffset field of hydra.ext.parquet.format.RowGroup
rowGroupFileOffset :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int64)
rowGroupFileOffset x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
        Model.projectionFieldName = (Model.Name "fileOffset")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the numRows field of hydra.ext.parquet.format.RowGroup
rowGroupNumRows :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm I.Int64
rowGroupNumRows x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
        Model.projectionFieldName = (Model.Name "numRows")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the ordinal field of hydra.ext.parquet.format.RowGroup
rowGroupOrdinal :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int16)
rowGroupOrdinal x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
        Model.projectionFieldName = (Model.Name "ordinal")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.RowGroup
rowGroupRowGroup :: Typed.TypedName Format.RowGroup
rowGroupRowGroup = Typed.TypedName (Model.Name "hydra.ext.parquet.format.RowGroup")

-- | DSL accessor for the sortingColumns field of hydra.ext.parquet.format.RowGroup
rowGroupSortingColumns :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe [Format.SortingColumn])
rowGroupSortingColumns x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
        Model.projectionFieldName = (Model.Name "sortingColumns")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the totalByteSize field of hydra.ext.parquet.format.RowGroup
rowGroupTotalByteSize :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm I.Int64
rowGroupTotalByteSize x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
        Model.projectionFieldName = (Model.Name "totalByteSize")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the totalCompressedSize field of hydra.ext.parquet.format.RowGroup
rowGroupTotalCompressedSize :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int64)
rowGroupTotalCompressedSize x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
        Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the columns field of hydra.ext.parquet.format.RowGroup
rowGroupWithColumns :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm [Format.ColumnChunk] -> Typed.TypedTerm Format.RowGroup
rowGroupWithColumns original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columns"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "totalByteSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalByteSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "sortingColumns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "sortingColumns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ordinal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "ordinal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the fileOffset field of hydra.ext.parquet.format.RowGroup
rowGroupWithFileOffset :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.RowGroup
rowGroupWithFileOffset original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "columns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalByteSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalByteSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "sortingColumns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "sortingColumns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ordinal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "ordinal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the numRows field of hydra.ext.parquet.format.RowGroup
rowGroupWithNumRows :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.RowGroup
rowGroupWithNumRows original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "columns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalByteSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalByteSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "sortingColumns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "sortingColumns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ordinal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "ordinal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the ordinal field of hydra.ext.parquet.format.RowGroup
rowGroupWithOrdinal :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int16) -> Typed.TypedTerm Format.RowGroup
rowGroupWithOrdinal original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "columns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalByteSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalByteSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "sortingColumns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "sortingColumns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ordinal"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the sortingColumns field of hydra.ext.parquet.format.RowGroup
rowGroupWithSortingColumns :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe [Format.SortingColumn]) -> Typed.TypedTerm Format.RowGroup
rowGroupWithSortingColumns original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "columns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalByteSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalByteSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "sortingColumns"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ordinal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "ordinal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the totalByteSize field of hydra.ext.parquet.format.RowGroup
rowGroupWithTotalByteSize :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Format.RowGroup
rowGroupWithTotalByteSize original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "columns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalByteSize"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "sortingColumns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "sortingColumns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalCompressedSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ordinal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "ordinal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the totalCompressedSize field of hydra.ext.parquet.format.RowGroup
rowGroupWithTotalCompressedSize :: Typed.TypedTerm Format.RowGroup -> Typed.TypedTerm (Maybe I.Int64) -> Typed.TypedTerm Format.RowGroup
rowGroupWithTotalCompressedSize original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "columns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalByteSize"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "totalByteSize")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numRows"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "numRows")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "sortingColumns"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "sortingColumns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fileOffset"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "fileOffset")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "totalCompressedSize"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "ordinal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.RowGroup"),
              Model.projectionFieldName = (Model.Name "ordinal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.parquet.format.SchemaElement
schemaElement :: Typed.TypedTerm (Maybe Format.Type) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Format.FieldRepetitionType) -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Format.LogicalType) -> Typed.TypedTerm Format.SchemaElement
schemaElement type_ typeLength repetitionType name numChildren fieldId logicalType =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "typeLength"),
          Model.fieldTerm = (Typed.unTypedTerm typeLength)},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionType"),
          Model.fieldTerm = (Typed.unTypedTerm repetitionType)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "numChildren"),
          Model.fieldTerm = (Typed.unTypedTerm numChildren)},
        Model.Field {
          Model.fieldName = (Model.Name "fieldId"),
          Model.fieldTerm = (Typed.unTypedTerm fieldId)},
        Model.Field {
          Model.fieldName = (Model.Name "logicalType"),
          Model.fieldTerm = (Typed.unTypedTerm logicalType)}]}))

-- | DSL accessor for the fieldId field of hydra.ext.parquet.format.SchemaElement
schemaElementFieldId :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int)
schemaElementFieldId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
        Model.projectionFieldName = (Model.Name "fieldId")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the logicalType field of hydra.ext.parquet.format.SchemaElement
schemaElementLogicalType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.LogicalType)
schemaElementLogicalType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
        Model.projectionFieldName = (Model.Name "logicalType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL accessor for the numChildren field of hydra.ext.parquet.format.SchemaElement
schemaElementNumChildren :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int)
schemaElementNumChildren x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
        Model.projectionFieldName = (Model.Name "numChildren")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the repetitionType field of hydra.ext.parquet.format.SchemaElement
schemaElementRepetitionType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.FieldRepetitionType)
schemaElementRepetitionType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
        Model.projectionFieldName = (Model.Name "repetitionType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.SchemaElement
schemaElementSchemaElement :: Typed.TypedName Format.SchemaElement
schemaElementSchemaElement = Typed.TypedName (Model.Name "hydra.ext.parquet.format.SchemaElement")

-- | DSL accessor for the type field of hydra.ext.parquet.format.SchemaElement
schemaElementType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.Type)
schemaElementType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the typeLength field of hydra.ext.parquet.format.SchemaElement
schemaElementTypeLength :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int)
schemaElementTypeLength x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
        Model.projectionFieldName = (Model.Name "typeLength")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the fieldId field of hydra.ext.parquet.format.SchemaElement
schemaElementWithFieldId :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.SchemaElement
schemaElementWithFieldId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
      Model.recordFields = [
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "typeLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "repetitionType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numChildren"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "numChildren")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fieldId"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "logicalType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "logicalType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the logicalType field of hydra.ext.parquet.format.SchemaElement
schemaElementWithLogicalType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.LogicalType) -> Typed.TypedTerm Format.SchemaElement
schemaElementWithLogicalType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
      Model.recordFields = [
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "typeLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "repetitionType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numChildren"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "numChildren")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fieldId"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "fieldId")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "logicalType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.parquet.format.SchemaElement
schemaElementWithName :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm String -> Typed.TypedTerm Format.SchemaElement
schemaElementWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
      Model.recordFields = [
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "typeLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "repetitionType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "numChildren"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "numChildren")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fieldId"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "fieldId")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "logicalType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "logicalType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the numChildren field of hydra.ext.parquet.format.SchemaElement
schemaElementWithNumChildren :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.SchemaElement
schemaElementWithNumChildren original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
      Model.recordFields = [
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "typeLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "repetitionType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numChildren"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "fieldId"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "fieldId")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "logicalType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "logicalType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the repetitionType field of hydra.ext.parquet.format.SchemaElement
schemaElementWithRepetitionType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.FieldRepetitionType) -> Typed.TypedTerm Format.SchemaElement
schemaElementWithRepetitionType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
      Model.recordFields = [
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "typeLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numChildren"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "numChildren")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fieldId"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "fieldId")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "logicalType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "logicalType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.parquet.format.SchemaElement
schemaElementWithType :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Format.Type) -> Typed.TypedTerm Format.SchemaElement
schemaElementWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeLength"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "typeLength")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "repetitionType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numChildren"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "numChildren")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fieldId"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "fieldId")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "logicalType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "logicalType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeLength field of hydra.ext.parquet.format.SchemaElement
schemaElementWithTypeLength :: Typed.TypedTerm Format.SchemaElement -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Format.SchemaElement
schemaElementWithTypeLength original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
      Model.recordFields = [
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeLength"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "repetitionType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "repetitionType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "numChildren"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "numChildren")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fieldId"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "fieldId")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "logicalType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SchemaElement"),
              Model.projectionFieldName = (Model.Name "logicalType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.parquet.format.SortingColumn
sortingColumn :: Typed.TypedTerm Int -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.SortingColumn
sortingColumn columnIdx descending nullsFirst =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columnIdx"),
          Model.fieldTerm = (Typed.unTypedTerm columnIdx)},
        Model.Field {
          Model.fieldName = (Model.Name "descending"),
          Model.fieldTerm = (Typed.unTypedTerm descending)},
        Model.Field {
          Model.fieldName = (Model.Name "nullsFirst"),
          Model.fieldTerm = (Typed.unTypedTerm nullsFirst)}]}))

-- | DSL accessor for the columnIdx field of hydra.ext.parquet.format.SortingColumn
sortingColumnColumnIdx :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Int
sortingColumnColumnIdx x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
        Model.projectionFieldName = (Model.Name "columnIdx")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the descending field of hydra.ext.parquet.format.SortingColumn
sortingColumnDescending :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Bool
sortingColumnDescending x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
        Model.projectionFieldName = (Model.Name "descending")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the nullsFirst field of hydra.ext.parquet.format.SortingColumn
sortingColumnNullsFirst :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Bool
sortingColumnNullsFirst x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
        Model.projectionFieldName = (Model.Name "nullsFirst")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.SortingColumn
sortingColumnSortingColumn :: Typed.TypedName Format.SortingColumn
sortingColumnSortingColumn = Typed.TypedName (Model.Name "hydra.ext.parquet.format.SortingColumn")

-- | DSL updater for the columnIdx field of hydra.ext.parquet.format.SortingColumn
sortingColumnWithColumnIdx :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Int -> Typed.TypedTerm Format.SortingColumn
sortingColumnWithColumnIdx original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columnIdx"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "descending"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
              Model.projectionFieldName = (Model.Name "descending")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullsFirst"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
              Model.projectionFieldName = (Model.Name "nullsFirst")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the descending field of hydra.ext.parquet.format.SortingColumn
sortingColumnWithDescending :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.SortingColumn
sortingColumnWithDescending original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columnIdx"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
              Model.projectionFieldName = (Model.Name "columnIdx")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "descending"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "nullsFirst"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
              Model.projectionFieldName = (Model.Name "nullsFirst")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the nullsFirst field of hydra.ext.parquet.format.SortingColumn
sortingColumnWithNullsFirst :: Typed.TypedTerm Format.SortingColumn -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.SortingColumn
sortingColumnWithNullsFirst original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columnIdx"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
              Model.projectionFieldName = (Model.Name "columnIdx")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "descending"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.SortingColumn"),
              Model.projectionFieldName = (Model.Name "descending")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullsFirst"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.parquet.format.Statistics
statistics :: Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.Statistics
statistics nullCount distinctCount maxValue minValue =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "nullCount"),
          Model.fieldTerm = (Typed.unTypedTerm nullCount)},
        Model.Field {
          Model.fieldName = (Model.Name "distinctCount"),
          Model.fieldTerm = (Typed.unTypedTerm distinctCount)},
        Model.Field {
          Model.fieldName = (Model.Name "maxValue"),
          Model.fieldTerm = (Typed.unTypedTerm maxValue)},
        Model.Field {
          Model.fieldName = (Model.Name "minValue"),
          Model.fieldTerm = (Typed.unTypedTerm minValue)}]}))

-- | DSL accessor for the distinctCount field of hydra.ext.parquet.format.Statistics
statisticsDistinctCount :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe Integer)
statisticsDistinctCount x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
        Model.projectionFieldName = (Model.Name "distinctCount")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the maxValue field of hydra.ext.parquet.format.Statistics
statisticsMaxValue :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe B.ByteString)
statisticsMaxValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
        Model.projectionFieldName = (Model.Name "maxValue")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the minValue field of hydra.ext.parquet.format.Statistics
statisticsMinValue :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe B.ByteString)
statisticsMinValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
        Model.projectionFieldName = (Model.Name "minValue")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the nullCount field of hydra.ext.parquet.format.Statistics
statisticsNullCount :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe Integer)
statisticsNullCount x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
        Model.projectionFieldName = (Model.Name "nullCount")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.Statistics
statisticsStatistics :: Typed.TypedName Format.Statistics
statisticsStatistics = Typed.TypedName (Model.Name "hydra.ext.parquet.format.Statistics")

-- | DSL updater for the distinctCount field of hydra.ext.parquet.format.Statistics
statisticsWithDistinctCount :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm Format.Statistics
statisticsWithDistinctCount original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "nullCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "nullCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "distinctCount"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "maxValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "maxValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "minValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the maxValue field of hydra.ext.parquet.format.Statistics
statisticsWithMaxValue :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.Statistics
statisticsWithMaxValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "nullCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "nullCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "distinctCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "distinctCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxValue"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "minValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "minValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the minValue field of hydra.ext.parquet.format.Statistics
statisticsWithMinValue :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe B.ByteString) -> Typed.TypedTerm Format.Statistics
statisticsWithMinValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "nullCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "nullCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "distinctCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "distinctCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "maxValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minValue"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the nullCount field of hydra.ext.parquet.format.Statistics
statisticsWithNullCount :: Typed.TypedTerm Format.Statistics -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm Format.Statistics
statisticsWithNullCount original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "nullCount"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "distinctCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "distinctCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "maxValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.Statistics"),
              Model.projectionFieldName = (Model.Name "minValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.parquet.format.TimeType
timeType :: Typed.TypedTerm Bool -> Typed.TypedTerm Format.TimeUnit -> Typed.TypedTerm Format.TimeType
timeType isAdjustedToUtc unit =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "isAdjustedToUtc"),
          Model.fieldTerm = (Typed.unTypedTerm isAdjustedToUtc)},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Typed.unTypedTerm unit)}]}))

-- | DSL accessor for the isAdjustedToUtc field of hydra.ext.parquet.format.TimeType
timeTypeIsAdjustedToUtc :: Typed.TypedTerm Format.TimeType -> Typed.TypedTerm Bool
timeTypeIsAdjustedToUtc x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"),
        Model.projectionFieldName = (Model.Name "isAdjustedToUtc")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.TimeType
timeTypeTimeType :: Typed.TypedName Format.TimeType
timeTypeTimeType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.TimeType")

-- | DSL accessor for the unit field of hydra.ext.parquet.format.TimeType
timeTypeUnit :: Typed.TypedTerm Format.TimeType -> Typed.TypedTerm Format.TimeUnit
timeTypeUnit x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"),
        Model.projectionFieldName = (Model.Name "unit")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the isAdjustedToUtc field of hydra.ext.parquet.format.TimeType
timeTypeWithIsAdjustedToUtc :: Typed.TypedTerm Format.TimeType -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.TimeType
timeTypeWithIsAdjustedToUtc original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "isAdjustedToUtc"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the unit field of hydra.ext.parquet.format.TimeType
timeTypeWithUnit :: Typed.TypedTerm Format.TimeType -> Typed.TypedTerm Format.TimeUnit -> Typed.TypedTerm Format.TimeType
timeTypeWithUnit original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "isAdjustedToUtc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeType"),
              Model.projectionFieldName = (Model.Name "isAdjustedToUtc")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the micros variant of hydra.ext.parquet.format.TimeUnit
timeUnitMicros :: Typed.TypedTerm Format.TimeUnit
timeUnitMicros =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeUnit"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "micros"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the millis variant of hydra.ext.parquet.format.TimeUnit
timeUnitMillis :: Typed.TypedTerm Format.TimeUnit
timeUnitMillis =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeUnit"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "millis"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the nanos variant of hydra.ext.parquet.format.TimeUnit
timeUnitNanos :: Typed.TypedTerm Format.TimeUnit
timeUnitNanos =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.TimeUnit"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nanos"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.parquet.format.TimeUnit
timeUnitTimeUnit :: Typed.TypedName Format.TimeUnit
timeUnitTimeUnit = Typed.TypedName (Model.Name "hydra.ext.parquet.format.TimeUnit")

-- | DSL constructor for hydra.ext.parquet.format.TimestampType
timestampType :: Typed.TypedTerm Bool -> Typed.TypedTerm Format.TimeUnit -> Typed.TypedTerm Format.TimestampType
timestampType isAdjustedToUtc unit =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "isAdjustedToUtc"),
          Model.fieldTerm = (Typed.unTypedTerm isAdjustedToUtc)},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Typed.unTypedTerm unit)}]}))

-- | DSL accessor for the isAdjustedToUtc field of hydra.ext.parquet.format.TimestampType
timestampTypeIsAdjustedToUtc :: Typed.TypedTerm Format.TimestampType -> Typed.TypedTerm Bool
timestampTypeIsAdjustedToUtc x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"),
        Model.projectionFieldName = (Model.Name "isAdjustedToUtc")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.parquet.format.TimestampType
timestampTypeTimestampType :: Typed.TypedName Format.TimestampType
timestampTypeTimestampType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.TimestampType")

-- | DSL accessor for the unit field of hydra.ext.parquet.format.TimestampType
timestampTypeUnit :: Typed.TypedTerm Format.TimestampType -> Typed.TypedTerm Format.TimeUnit
timestampTypeUnit x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"),
        Model.projectionFieldName = (Model.Name "unit")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the isAdjustedToUtc field of hydra.ext.parquet.format.TimestampType
timestampTypeWithIsAdjustedToUtc :: Typed.TypedTerm Format.TimestampType -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.TimestampType
timestampTypeWithIsAdjustedToUtc original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "isAdjustedToUtc"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the unit field of hydra.ext.parquet.format.TimestampType
timestampTypeWithUnit :: Typed.TypedTerm Format.TimestampType -> Typed.TypedTerm Format.TimeUnit -> Typed.TypedTerm Format.TimestampType
timestampTypeWithUnit original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "isAdjustedToUtc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.parquet.format.TimestampType"),
              Model.projectionFieldName = (Model.Name "isAdjustedToUtc")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

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

-- | DSL injection for the byteArray variant of hydra.ext.parquet.format.Type
typeByteArray :: Typed.TypedTerm Format.Type
typeByteArray =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "byteArray"),
        Model.fieldTerm = Model.TermUnit}}))

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

-- | DSL injection for the fixedLenByteArray variant of hydra.ext.parquet.format.Type
typeFixedLenByteArray :: Typed.TypedTerm Format.Type
typeFixedLenByteArray =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "fixedLenByteArray"),
        Model.fieldTerm = Model.TermUnit}}))

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

-- | DSL injection for the int32 variant of hydra.ext.parquet.format.Type
typeInt32 :: Typed.TypedTerm Format.Type
typeInt32 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int32"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int64 variant of hydra.ext.parquet.format.Type
typeInt64 :: Typed.TypedTerm Format.Type
typeInt64 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.parquet.format.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int64"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.parquet.format.Type
typeType :: Typed.TypedName Format.Type
typeType = Typed.TypedName (Model.Name "hydra.ext.parquet.format.Type")