hydra-ext-0.18.0: src/main/haskell/Hydra/Ext/Dsl/Kusto/Kql.hs

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

-- | DSL functions for hydra.ext.kusto.kql

module Hydra.Ext.Dsl.Kusto.Kql where

import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Ext.Kusto.Kql as Kql
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.Int as I

-- | DSL constructor for hydra.ext.kusto.kql.BetweenExpression
betweenExpression :: Typed.TypedTerm Bool -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BetweenExpression
betweenExpression not expression lowerBound upperBound =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "not"),
          Model.fieldTerm = (Typed.unTypedTerm not)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "lowerBound"),
          Model.fieldTerm = (Typed.unTypedTerm lowerBound)},
        Model.Field {
          Model.fieldName = (Model.Name "upperBound"),
          Model.fieldTerm = (Typed.unTypedTerm upperBound)}]}))

-- | DSL name token for hydra.ext.kusto.kql.BetweenExpression
betweenExpressionBetweenExpression :: Typed.TypedName Kql.BetweenExpression
betweenExpressionBetweenExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.BetweenExpression")

-- | DSL accessor for the expression field of hydra.ext.kusto.kql.BetweenExpression
betweenExpressionExpression :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression
betweenExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the lowerBound field of hydra.ext.kusto.kql.BetweenExpression
betweenExpressionLowerBound :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression
betweenExpressionLowerBound x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
        Model.projectionFieldName = (Model.Name "lowerBound")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the not field of hydra.ext.kusto.kql.BetweenExpression
betweenExpressionNot :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Bool
betweenExpressionNot x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
        Model.projectionFieldName = (Model.Name "not")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the upperBound field of hydra.ext.kusto.kql.BetweenExpression
betweenExpressionUpperBound :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression
betweenExpressionUpperBound x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
        Model.projectionFieldName = (Model.Name "upperBound")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.kusto.kql.BetweenExpression
betweenExpressionWithExpression :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BetweenExpression
betweenExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "not"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "not")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "lowerBound"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "lowerBound")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "upperBound"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "upperBound")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the lowerBound field of hydra.ext.kusto.kql.BetweenExpression
betweenExpressionWithLowerBound :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BetweenExpression
betweenExpressionWithLowerBound original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "not"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "not")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "lowerBound"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "upperBound"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "upperBound")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the not field of hydra.ext.kusto.kql.BetweenExpression
betweenExpressionWithNot :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Bool -> Typed.TypedTerm Kql.BetweenExpression
betweenExpressionWithNot original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "not"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "lowerBound"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "lowerBound")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "upperBound"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "upperBound")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the upperBound field of hydra.ext.kusto.kql.BetweenExpression
betweenExpressionWithUpperBound :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BetweenExpression
betweenExpressionWithUpperBound original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "not"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "not")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "lowerBound"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BetweenExpression"),
              Model.projectionFieldName = (Model.Name "lowerBound")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "upperBound"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.kusto.kql.BinaryExpression
binaryExpression :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BinaryOperator -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BinaryExpression
binaryExpression left operator right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm operator)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.kusto.kql.BinaryExpression
binaryExpressionBinaryExpression :: Typed.TypedName Kql.BinaryExpression
binaryExpressionBinaryExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.BinaryExpression")

-- | DSL accessor for the left field of hydra.ext.kusto.kql.BinaryExpression
binaryExpressionLeft :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.Expression
binaryExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the operator field of hydra.ext.kusto.kql.BinaryExpression
binaryExpressionOperator :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.BinaryOperator
binaryExpressionOperator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
        Model.projectionFieldName = (Model.Name "operator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.kusto.kql.BinaryExpression
binaryExpressionRight :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.Expression
binaryExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.kusto.kql.BinaryExpression
binaryExpressionWithLeft :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BinaryExpression
binaryExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the operator field of hydra.ext.kusto.kql.BinaryExpression
binaryExpressionWithOperator :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.BinaryOperator -> Typed.TypedTerm Kql.BinaryExpression
binaryExpressionWithOperator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.kusto.kql.BinaryExpression
binaryExpressionWithRight :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.BinaryExpression
binaryExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL name token for hydra.ext.kusto.kql.BinaryOperator
binaryOperatorBinaryOperator :: Typed.TypedName Kql.BinaryOperator
binaryOperatorBinaryOperator = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.BinaryOperator")

-- | DSL injection for the caseInsensitiveEqual variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorCaseInsensitiveEqual :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorCaseInsensitiveEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "caseInsensitiveEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the contains variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorContains :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorContains =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "contains"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the divide variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorDivide :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorDivide =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "divide"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the endsWith variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorEndsWith :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorEndsWith =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "endsWith"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the equal variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorEqual :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "equal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the greater variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorGreater :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorGreater =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "greater"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the greaterOrEqual variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorGreaterOrEqual :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorGreaterOrEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "greaterOrEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the has variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorHas :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorHas =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "has"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the hasPrefix variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorHasPrefix :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorHasPrefix =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "hasPrefix"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the hasSuffix variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorHasSuffix :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorHasSuffix =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "hasSuffix"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the less variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorLess :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorLess =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "less"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the lessOrEqual variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorLessOrEqual :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorLessOrEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lessOrEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the matchesRegex variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorMatchesRegex :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorMatchesRegex =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "matchesRegex"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the minus variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorMinus :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorMinus =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minus"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the notEqual variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorNotEqual :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorNotEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "notEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the plus variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorPlus :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorPlus =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "plus"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the startsWith variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorStartsWith :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorStartsWith =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "startsWith"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the times variant of hydra.ext.kusto.kql.BinaryOperator
binaryOperatorTimes :: Typed.TypedTerm Kql.BinaryOperator
binaryOperatorTimes =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "times"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the ago variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionAgo :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionAgo =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ago"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the bin variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionBin :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionBin =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bin"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionBuiltInFunction :: Typed.TypedName Kql.BuiltInFunction
builtInFunctionBuiltInFunction = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.BuiltInFunction")

-- | DSL injection for the count variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionCount :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionCount =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "count"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the dcount variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionDcount :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionDcount =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "dcount"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the endofday variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionEndofday :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionEndofday =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "endofday"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the extract variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionExtract :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionExtract =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "extract"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the format_datetime variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionFormat_datetime :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionFormat_datetime =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "format_datetime"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the materialize variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionMaterialize :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionMaterialize =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "materialize"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the now variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionNow :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionNow =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "now"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the range variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionRange :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionRange =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "range"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the startofday variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionStartofday :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionStartofday =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "startofday"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the strcat variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionStrcat :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionStrcat =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "strcat"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the todynamic variant of hydra.ext.kusto.kql.BuiltInFunction
builtInFunctionTodynamic :: Typed.TypedTerm Kql.BuiltInFunction
builtInFunctionTodynamic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.BuiltInFunction"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "todynamic"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.kusto.kql.ColumnAlias
columnAlias :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ColumnAlias
columnAlias column alias =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Typed.unTypedTerm column)},
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Typed.unTypedTerm alias)}]}))

-- | DSL accessor for the alias field of hydra.ext.kusto.kql.ColumnAlias
columnAliasAlias :: Typed.TypedTerm Kql.ColumnAlias -> Typed.TypedTerm Kql.ColumnName
columnAliasAlias x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"),
        Model.projectionFieldName = (Model.Name "alias")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the column field of hydra.ext.kusto.kql.ColumnAlias
columnAliasColumn :: Typed.TypedTerm Kql.ColumnAlias -> Typed.TypedTerm Kql.ColumnName
columnAliasColumn x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"),
        Model.projectionFieldName = (Model.Name "column")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.ColumnAlias
columnAliasColumnAlias :: Typed.TypedName Kql.ColumnAlias
columnAliasColumnAlias = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.ColumnAlias")

-- | DSL updater for the alias field of hydra.ext.kusto.kql.ColumnAlias
columnAliasWithAlias :: Typed.TypedTerm Kql.ColumnAlias -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ColumnAlias
columnAliasWithAlias original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"),
              Model.projectionFieldName = (Model.Name "column")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the column field of hydra.ext.kusto.kql.ColumnAlias
columnAliasWithColumn :: Typed.TypedTerm Kql.ColumnAlias -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ColumnAlias
columnAliasWithColumn original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAlias"),
              Model.projectionFieldName = (Model.Name "alias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.kusto.kql.ColumnAssignment
columnAssignment :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.ColumnAssignment
columnAssignment column expression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Typed.unTypedTerm column)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)}]}))

-- | DSL accessor for the column field of hydra.ext.kusto.kql.ColumnAssignment
columnAssignmentColumn :: Typed.TypedTerm Kql.ColumnAssignment -> Typed.TypedTerm Kql.ColumnName
columnAssignmentColumn x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"),
        Model.projectionFieldName = (Model.Name "column")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.ColumnAssignment
columnAssignmentColumnAssignment :: Typed.TypedName Kql.ColumnAssignment
columnAssignmentColumnAssignment = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.ColumnAssignment")

-- | DSL accessor for the expression field of hydra.ext.kusto.kql.ColumnAssignment
columnAssignmentExpression :: Typed.TypedTerm Kql.ColumnAssignment -> Typed.TypedTerm Kql.Expression
columnAssignmentExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the column field of hydra.ext.kusto.kql.ColumnAssignment
columnAssignmentWithColumn :: Typed.TypedTerm Kql.ColumnAssignment -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ColumnAssignment
columnAssignmentWithColumn original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the expression field of hydra.ext.kusto.kql.ColumnAssignment
columnAssignmentWithExpression :: Typed.TypedTerm Kql.ColumnAssignment -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.ColumnAssignment
columnAssignmentWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnAssignment"),
              Model.projectionFieldName = (Model.Name "column")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for the hydra.ext.kusto.kql.ColumnName wrapper
columnName :: Typed.TypedTerm String -> Typed.TypedTerm Kql.ColumnName
columnName x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.ColumnName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.ColumnName
columnNameColumnName :: Typed.TypedName Kql.ColumnName
columnNameColumnName = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.ColumnName")

-- | DSL injection for the all variant of hydra.ext.kusto.kql.Columns
columnsAll :: Typed.TypedTerm Kql.Columns
columnsAll =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Columns"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "all"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.kusto.kql.Columns
columnsColumns :: Typed.TypedName Kql.Columns
columnsColumns = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Columns")

-- | DSL injection for the single variant of hydra.ext.kusto.kql.Columns
columnsSingle :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.Columns
columnsSingle x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Columns"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "single"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.kusto.kql.Command
commandCommand :: Typed.TypedName Kql.Command
commandCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Command")

-- | DSL injection for the count variant of hydra.ext.kusto.kql.Command
commandCount :: Typed.TypedTerm Kql.Command
commandCount =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "count"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the distinct variant of hydra.ext.kusto.kql.Command
commandDistinct :: Typed.TypedTerm [Kql.ColumnName] -> Typed.TypedTerm Kql.Command
commandDistinct x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "distinct"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the extend variant of hydra.ext.kusto.kql.Command
commandExtend :: Typed.TypedTerm [Kql.ColumnAssignment] -> Typed.TypedTerm Kql.Command
commandExtend x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "extend"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the join variant of hydra.ext.kusto.kql.Command
commandJoin :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.Command
commandJoin x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "join"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the limit variant of hydra.ext.kusto.kql.Command
commandLimit :: Typed.TypedTerm Int -> Typed.TypedTerm Kql.Command
commandLimit x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "limit"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the mvexpand variant of hydra.ext.kusto.kql.Command
commandMvexpand :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.Command
commandMvexpand x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "mvexpand"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the orderBy variant of hydra.ext.kusto.kql.Command
commandOrderBy :: Typed.TypedTerm [Kql.SortBy] -> Typed.TypedTerm Kql.Command
commandOrderBy x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "orderBy"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the parse variant of hydra.ext.kusto.kql.Command
commandParse :: Typed.TypedTerm Kql.ParseCommand -> Typed.TypedTerm Kql.Command
commandParse x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "parse"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the print variant of hydra.ext.kusto.kql.Command
commandPrint :: Typed.TypedTerm Kql.PrintCommand -> Typed.TypedTerm Kql.Command
commandPrint x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "print"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the project variant of hydra.ext.kusto.kql.Command
commandProject :: Typed.TypedTerm [Kql.Projection] -> Typed.TypedTerm Kql.Command
commandProject x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "project"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the projectAway variant of hydra.ext.kusto.kql.Command
commandProjectAway :: Typed.TypedTerm [Kql.ColumnName] -> Typed.TypedTerm Kql.Command
commandProjectAway x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "projectAway"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the projectRename variant of hydra.ext.kusto.kql.Command
commandProjectRename :: Typed.TypedTerm [Kql.ColumnAlias] -> Typed.TypedTerm Kql.Command
commandProjectRename x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "projectRename"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the render variant of hydra.ext.kusto.kql.Command
commandRender :: Typed.TypedTerm String -> Typed.TypedTerm Kql.Command
commandRender x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "render"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the search variant of hydra.ext.kusto.kql.Command
commandSearch :: Typed.TypedTerm Kql.SearchCommand -> Typed.TypedTerm Kql.Command
commandSearch x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "search"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the sortBy variant of hydra.ext.kusto.kql.Command
commandSortBy :: Typed.TypedTerm [Kql.SortBy] -> Typed.TypedTerm Kql.Command
commandSortBy x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sortBy"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the summarize variant of hydra.ext.kusto.kql.Command
commandSummarize :: Typed.TypedTerm Kql.SummarizeCommand -> Typed.TypedTerm Kql.Command
commandSummarize x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "summarize"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the take variant of hydra.ext.kusto.kql.Command
commandTake :: Typed.TypedTerm Int -> Typed.TypedTerm Kql.Command
commandTake x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "take"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the top variant of hydra.ext.kusto.kql.Command
commandTop :: Typed.TypedTerm Kql.TopCommand -> Typed.TypedTerm Kql.Command
commandTop x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "top"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the union variant of hydra.ext.kusto.kql.Command
commandUnion :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm Kql.Command
commandUnion x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "union"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the where variant of hydra.ext.kusto.kql.Command
commandWhere :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Command
commandWhere x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Command"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "where"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.kusto.kql.Datetime wrapper
datetime :: Typed.TypedTerm String -> Typed.TypedTerm Kql.Datetime
datetime x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.Datetime"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.Datetime
datetimeDatetime :: Typed.TypedName Kql.Datetime
datetimeDatetime = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Datetime")

-- | DSL constructor for hydra.ext.kusto.kql.Duration
duration :: Typed.TypedTerm Int -> Typed.TypedTerm Kql.DurationUnit -> Typed.TypedTerm Kql.Duration
duration value unit =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Typed.unTypedTerm unit)}]}))

-- | DSL name token for hydra.ext.kusto.kql.Duration
durationDuration :: Typed.TypedName Kql.Duration
durationDuration = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Duration")

-- | DSL accessor for the unit field of hydra.ext.kusto.kql.Duration
durationUnit :: Typed.TypedTerm Kql.Duration -> Typed.TypedTerm Kql.DurationUnit
durationUnit x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"),
        Model.projectionFieldName = (Model.Name "unit")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.DurationUnit
durationUnitDurationUnit :: Typed.TypedName Kql.DurationUnit
durationUnitDurationUnit = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.DurationUnit")

-- | DSL injection for the hour variant of hydra.ext.kusto.kql.DurationUnit
durationUnitHour :: Typed.TypedTerm Kql.DurationUnit
durationUnitHour =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.DurationUnit"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "hour"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the minute variant of hydra.ext.kusto.kql.DurationUnit
durationUnitMinute :: Typed.TypedTerm Kql.DurationUnit
durationUnitMinute =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.DurationUnit"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minute"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the second variant of hydra.ext.kusto.kql.DurationUnit
durationUnitSecond :: Typed.TypedTerm Kql.DurationUnit
durationUnitSecond =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.DurationUnit"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "second"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL accessor for the value field of hydra.ext.kusto.kql.Duration
durationValue :: Typed.TypedTerm Kql.Duration -> Typed.TypedTerm Int
durationValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the unit field of hydra.ext.kusto.kql.Duration
durationWithUnit :: Typed.TypedTerm Kql.Duration -> Typed.TypedTerm Kql.DurationUnit -> Typed.TypedTerm Kql.Duration
durationWithUnit original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the value field of hydra.ext.kusto.kql.Duration
durationWithValue :: Typed.TypedTerm Kql.Duration -> Typed.TypedTerm Int -> Typed.TypedTerm Kql.Duration
durationWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Duration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          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.kusto.kql.Duration"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the and variant of hydra.ext.kusto.kql.Expression
expressionAnd :: Typed.TypedTerm [Kql.Expression] -> Typed.TypedTerm Kql.Expression
expressionAnd x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "and"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the any variant of hydra.ext.kusto.kql.Expression
expressionAny :: Typed.TypedTerm Kql.Expression
expressionAny =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "any"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the between variant of hydra.ext.kusto.kql.Expression
expressionBetween :: Typed.TypedTerm Kql.BetweenExpression -> Typed.TypedTerm Kql.Expression
expressionBetween x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "between"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the binary variant of hydra.ext.kusto.kql.Expression
expressionBinary :: Typed.TypedTerm Kql.BinaryExpression -> Typed.TypedTerm Kql.Expression
expressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the braces variant of hydra.ext.kusto.kql.Expression
expressionBraces :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Expression
expressionBraces x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "braces"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the column variant of hydra.ext.kusto.kql.Expression
expressionColumn :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.Expression
expressionColumn x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "column"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the dataset variant of hydra.ext.kusto.kql.Expression
expressionDataset :: Typed.TypedTerm Kql.TableName -> Typed.TypedTerm Kql.Expression
expressionDataset x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "dataset"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.kusto.kql.Expression
expressionExpression :: Typed.TypedName Kql.Expression
expressionExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Expression")

-- | DSL injection for the index variant of hydra.ext.kusto.kql.Expression
expressionIndex :: Typed.TypedTerm Kql.IndexExpression -> Typed.TypedTerm Kql.Expression
expressionIndex x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "index"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the list variant of hydra.ext.kusto.kql.Expression
expressionList :: Typed.TypedTerm [Kql.Expression] -> Typed.TypedTerm Kql.Expression
expressionList x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "list"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the literal variant of hydra.ext.kusto.kql.Expression
expressionLiteral :: Typed.TypedTerm Kql.Literal -> Typed.TypedTerm Kql.Expression
expressionLiteral x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "literal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the or variant of hydra.ext.kusto.kql.Expression
expressionOr :: Typed.TypedTerm [Kql.Expression] -> Typed.TypedTerm Kql.Expression
expressionOr x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "or"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the parentheses variant of hydra.ext.kusto.kql.Expression
expressionParentheses :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Expression
expressionParentheses x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "parentheses"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the property variant of hydra.ext.kusto.kql.Expression
expressionProperty :: Typed.TypedTerm Kql.PropertyExpression -> Typed.TypedTerm Kql.Expression
expressionProperty x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "property"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the unary variant of hydra.ext.kusto.kql.Expression
expressionUnary :: Typed.TypedTerm Kql.UnaryExpression -> Typed.TypedTerm Kql.Expression
expressionUnary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the builtIn variant of hydra.ext.kusto.kql.Function
functionBuiltIn :: Typed.TypedTerm Kql.BuiltInFunction -> Typed.TypedTerm Kql.Function
functionBuiltIn x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Function"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "builtIn"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the custom variant of hydra.ext.kusto.kql.Function
functionCustom :: Typed.TypedTerm Kql.FunctionName -> Typed.TypedTerm Kql.Function
functionCustom x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Function"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "custom"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.kusto.kql.FunctionExpression
functionExpression :: Typed.TypedTerm Kql.Function -> Typed.TypedTerm [Kql.Expression] -> Typed.TypedTerm Kql.FunctionExpression
functionExpression function arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Typed.unTypedTerm function)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the arguments field of hydra.ext.kusto.kql.FunctionExpression
functionExpressionArguments :: Typed.TypedTerm Kql.FunctionExpression -> Typed.TypedTerm [Kql.Expression]
functionExpressionArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the function field of hydra.ext.kusto.kql.FunctionExpression
functionExpressionFunction :: Typed.TypedTerm Kql.FunctionExpression -> Typed.TypedTerm Kql.Function
functionExpressionFunction x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"),
        Model.projectionFieldName = (Model.Name "function")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.FunctionExpression
functionExpressionFunctionExpression :: Typed.TypedName Kql.FunctionExpression
functionExpressionFunctionExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.FunctionExpression")

-- | DSL updater for the arguments field of hydra.ext.kusto.kql.FunctionExpression
functionExpressionWithArguments :: Typed.TypedTerm Kql.FunctionExpression -> Typed.TypedTerm [Kql.Expression] -> Typed.TypedTerm Kql.FunctionExpression
functionExpressionWithArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"),
              Model.projectionFieldName = (Model.Name "function")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the function field of hydra.ext.kusto.kql.FunctionExpression
functionExpressionWithFunction :: Typed.TypedTerm Kql.FunctionExpression -> Typed.TypedTerm Kql.Function -> Typed.TypedTerm Kql.FunctionExpression
functionExpressionWithFunction original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionExpression"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.kusto.kql.Function
functionFunction :: Typed.TypedName Kql.Function
functionFunction = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Function")

-- | DSL constructor for the hydra.ext.kusto.kql.FunctionName wrapper
functionName :: Typed.TypedTerm String -> Typed.TypedTerm Kql.FunctionName
functionName x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.FunctionName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.FunctionName
functionNameFunctionName :: Typed.TypedName Kql.FunctionName
functionNameFunctionName = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.FunctionName")

-- | DSL constructor for hydra.ext.kusto.kql.IndexExpression
indexExpression :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm String -> Typed.TypedTerm Kql.IndexExpression
indexExpression expression index =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "index"),
          Model.fieldTerm = (Typed.unTypedTerm index)}]}))

-- | DSL accessor for the expression field of hydra.ext.kusto.kql.IndexExpression
indexExpressionExpression :: Typed.TypedTerm Kql.IndexExpression -> Typed.TypedTerm Kql.Expression
indexExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the index field of hydra.ext.kusto.kql.IndexExpression
indexExpressionIndex :: Typed.TypedTerm Kql.IndexExpression -> Typed.TypedTerm String
indexExpressionIndex x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"),
        Model.projectionFieldName = (Model.Name "index")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.IndexExpression
indexExpressionIndexExpression :: Typed.TypedName Kql.IndexExpression
indexExpressionIndexExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.IndexExpression")

-- | DSL updater for the expression field of hydra.ext.kusto.kql.IndexExpression
indexExpressionWithExpression :: Typed.TypedTerm Kql.IndexExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.IndexExpression
indexExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "index"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"),
              Model.projectionFieldName = (Model.Name "index")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the index field of hydra.ext.kusto.kql.IndexExpression
indexExpressionWithIndex :: Typed.TypedTerm Kql.IndexExpression -> Typed.TypedTerm String -> Typed.TypedTerm Kql.IndexExpression
indexExpressionWithIndex original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.IndexExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "index"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.kusto.kql.JoinCommand
joinCommand :: Typed.TypedTerm Kql.JoinKind -> Typed.TypedTerm Kql.TableName -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.JoinCommand
joinCommand kind expression on =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Typed.unTypedTerm kind)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "on"),
          Model.fieldTerm = (Typed.unTypedTerm on)}]}))

-- | DSL accessor for the expression field of hydra.ext.kusto.kql.JoinCommand
joinCommandExpression :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.TableName
joinCommandExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.JoinCommand
joinCommandJoinCommand :: Typed.TypedName Kql.JoinCommand
joinCommandJoinCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.JoinCommand")

-- | DSL accessor for the kind field of hydra.ext.kusto.kql.JoinCommand
joinCommandKind :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.JoinKind
joinCommandKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
        Model.projectionFieldName = (Model.Name "kind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the on field of hydra.ext.kusto.kql.JoinCommand
joinCommandOn :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.Expression
joinCommandOn x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
        Model.projectionFieldName = (Model.Name "on")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.kusto.kql.JoinCommand
joinCommandWithExpression :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.TableName -> Typed.TypedTerm Kql.JoinCommand
joinCommandWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "on"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
              Model.projectionFieldName = (Model.Name "on")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the kind field of hydra.ext.kusto.kql.JoinCommand
joinCommandWithKind :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.JoinKind -> Typed.TypedTerm Kql.JoinCommand
joinCommandWithKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "on"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
              Model.projectionFieldName = (Model.Name "on")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the on field of hydra.ext.kusto.kql.JoinCommand
joinCommandWithOn :: Typed.TypedTerm Kql.JoinCommand -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.JoinCommand
joinCommandWithOn original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinCommand"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "on"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the fullouter variant of hydra.ext.kusto.kql.JoinKind
joinKindFullouter :: Typed.TypedTerm Kql.JoinKind
joinKindFullouter =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "fullouter"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the inner variant of hydra.ext.kusto.kql.JoinKind
joinKindInner :: Typed.TypedTerm Kql.JoinKind
joinKindInner =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "inner"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the innerunique variant of hydra.ext.kusto.kql.JoinKind
joinKindInnerunique :: Typed.TypedTerm Kql.JoinKind
joinKindInnerunique =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "innerunique"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.kusto.kql.JoinKind
joinKindJoinKind :: Typed.TypedName Kql.JoinKind
joinKindJoinKind = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.JoinKind")

-- | DSL injection for the leftanti variant of hydra.ext.kusto.kql.JoinKind
joinKindLeftanti :: Typed.TypedTerm Kql.JoinKind
joinKindLeftanti =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "leftanti"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the leftouter variant of hydra.ext.kusto.kql.JoinKind
joinKindLeftouter :: Typed.TypedTerm Kql.JoinKind
joinKindLeftouter =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "leftouter"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the leftsemi variant of hydra.ext.kusto.kql.JoinKind
joinKindLeftsemi :: Typed.TypedTerm Kql.JoinKind
joinKindLeftsemi =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "leftsemi"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the rightanti variant of hydra.ext.kusto.kql.JoinKind
joinKindRightanti :: Typed.TypedTerm Kql.JoinKind
joinKindRightanti =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rightanti"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the rightouter variant of hydra.ext.kusto.kql.JoinKind
joinKindRightouter :: Typed.TypedTerm Kql.JoinKind
joinKindRightouter =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rightouter"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the rightsemi variant of hydra.ext.kusto.kql.JoinKind
joinKindRightsemi :: Typed.TypedTerm Kql.JoinKind
joinKindRightsemi =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.JoinKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rightsemi"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.kusto.kql.KeyValuePair
keyValuePair :: Typed.TypedTerm String -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.KeyValuePair
keyValuePair key value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"),
      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.kusto.kql.KeyValuePair
keyValuePairKey :: Typed.TypedTerm Kql.KeyValuePair -> Typed.TypedTerm String
keyValuePairKey x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"),
        Model.projectionFieldName = (Model.Name "key")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.KeyValuePair
keyValuePairKeyValuePair :: Typed.TypedName Kql.KeyValuePair
keyValuePairKeyValuePair = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.KeyValuePair")

-- | DSL accessor for the value field of hydra.ext.kusto.kql.KeyValuePair
keyValuePairValue :: Typed.TypedTerm Kql.KeyValuePair -> Typed.TypedTerm Kql.Expression
keyValuePairValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the key field of hydra.ext.kusto.kql.KeyValuePair
keyValuePairWithKey :: Typed.TypedTerm Kql.KeyValuePair -> Typed.TypedTerm String -> Typed.TypedTerm Kql.KeyValuePair
keyValuePairWithKey original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"),
      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.kusto.kql.KeyValuePair"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.ext.kusto.kql.KeyValuePair
keyValuePairWithValue :: Typed.TypedTerm Kql.KeyValuePair -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.KeyValuePair
keyValuePairWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.KeyValuePair"),
      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.kusto.kql.KeyValuePair"),
              Model.projectionFieldName = (Model.Name "key")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.kusto.kql.LetBinding
letBinding :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.LetBinding
letBinding name expression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)}]}))

-- | DSL accessor for the expression field of hydra.ext.kusto.kql.LetBinding
letBindingExpression :: Typed.TypedTerm Kql.LetBinding -> Typed.TypedTerm Kql.Expression
letBindingExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.LetBinding
letBindingLetBinding :: Typed.TypedName Kql.LetBinding
letBindingLetBinding = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.LetBinding")

-- | DSL accessor for the name field of hydra.ext.kusto.kql.LetBinding
letBindingName :: Typed.TypedTerm Kql.LetBinding -> Typed.TypedTerm Kql.ColumnName
letBindingName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.kusto.kql.LetBinding
letBindingWithExpression :: Typed.TypedTerm Kql.LetBinding -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.LetBinding
letBindingWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.kusto.kql.LetBinding
letBindingWithName :: Typed.TypedTerm Kql.LetBinding -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.LetBinding
letBindingWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetBinding"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.kusto.kql.LetExpression
letExpression :: Typed.TypedTerm [Kql.LetBinding] -> Typed.TypedTerm Kql.TabularExpression -> Typed.TypedTerm Kql.LetExpression
letExpression bindings expression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "bindings"),
          Model.fieldTerm = (Typed.unTypedTerm bindings)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)}]}))

-- | DSL accessor for the bindings field of hydra.ext.kusto.kql.LetExpression
letExpressionBindings :: Typed.TypedTerm Kql.LetExpression -> Typed.TypedTerm [Kql.LetBinding]
letExpressionBindings x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"),
        Model.projectionFieldName = (Model.Name "bindings")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expression field of hydra.ext.kusto.kql.LetExpression
letExpressionExpression :: Typed.TypedTerm Kql.LetExpression -> Typed.TypedTerm Kql.TabularExpression
letExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.LetExpression
letExpressionLetExpression :: Typed.TypedName Kql.LetExpression
letExpressionLetExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.LetExpression")

-- | DSL updater for the bindings field of hydra.ext.kusto.kql.LetExpression
letExpressionWithBindings :: Typed.TypedTerm Kql.LetExpression -> Typed.TypedTerm [Kql.LetBinding] -> Typed.TypedTerm Kql.LetExpression
letExpressionWithBindings original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "bindings"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the expression field of hydra.ext.kusto.kql.LetExpression
letExpressionWithExpression :: Typed.TypedTerm Kql.LetExpression -> Typed.TypedTerm Kql.TabularExpression -> Typed.TypedTerm Kql.LetExpression
letExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "bindings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.LetExpression"),
              Model.projectionFieldName = (Model.Name "bindings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the boolean variant of hydra.ext.kusto.kql.Literal
literalBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Kql.Literal
literalBoolean x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "boolean"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the datetime variant of hydra.ext.kusto.kql.Literal
literalDatetime :: Typed.TypedTerm Kql.Datetime -> Typed.TypedTerm Kql.Literal
literalDatetime x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "datetime"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the double variant of hydra.ext.kusto.kql.Literal
literalDouble :: Typed.TypedTerm Double -> Typed.TypedTerm Kql.Literal
literalDouble x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "double"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the duration variant of hydra.ext.kusto.kql.Literal
literalDuration :: Typed.TypedTerm Kql.Duration -> Typed.TypedTerm Kql.Literal
literalDuration x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "duration"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the int variant of hydra.ext.kusto.kql.Literal
literalInt :: Typed.TypedTerm Int -> Typed.TypedTerm Kql.Literal
literalInt x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.kusto.kql.Literal
literalLiteral :: Typed.TypedName Kql.Literal
literalLiteral = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Literal")

-- | DSL injection for the long variant of hydra.ext.kusto.kql.Literal
literalLong :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Kql.Literal
literalLong x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "long"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the string variant of hydra.ext.kusto.kql.Literal
literalString :: Typed.TypedTerm String -> Typed.TypedTerm Kql.Literal
literalString x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the ascending variant of hydra.ext.kusto.kql.Order
orderAscending :: Typed.TypedTerm Kql.Order
orderAscending =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Order"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ascending"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the descending variant of hydra.ext.kusto.kql.Order
orderDescending :: Typed.TypedTerm Kql.Order
orderDescending =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.Order"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "descending"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.kusto.kql.Order
orderOrder :: Typed.TypedName Kql.Order
orderOrder = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Order")

-- | DSL constructor for hydra.ext.kusto.kql.Parameter
parameter :: Typed.TypedTerm String -> Typed.TypedTerm Kql.Literal -> Typed.TypedTerm Kql.Parameter
parameter key value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"),
      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.kusto.kql.Parameter
parameterKey :: Typed.TypedTerm Kql.Parameter -> Typed.TypedTerm String
parameterKey x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"),
        Model.projectionFieldName = (Model.Name "key")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.Parameter
parameterParameter :: Typed.TypedName Kql.Parameter
parameterParameter = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Parameter")

-- | DSL accessor for the value field of hydra.ext.kusto.kql.Parameter
parameterValue :: Typed.TypedTerm Kql.Parameter -> Typed.TypedTerm Kql.Literal
parameterValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the key field of hydra.ext.kusto.kql.Parameter
parameterWithKey :: Typed.TypedTerm Kql.Parameter -> Typed.TypedTerm String -> Typed.TypedTerm Kql.Parameter
parameterWithKey original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"),
      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.kusto.kql.Parameter"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.ext.kusto.kql.Parameter
parameterWithValue :: Typed.TypedTerm Kql.Parameter -> Typed.TypedTerm Kql.Literal -> Typed.TypedTerm Kql.Parameter
parameterWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Parameter"),
      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.kusto.kql.Parameter"),
              Model.projectionFieldName = (Model.Name "key")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.kusto.kql.ParseCommand
parseCommand :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm [Kql.KeyValuePair] -> Typed.TypedTerm Kql.ParseCommand
parseCommand column pairs =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Typed.unTypedTerm column)},
        Model.Field {
          Model.fieldName = (Model.Name "pairs"),
          Model.fieldTerm = (Typed.unTypedTerm pairs)}]}))

-- | DSL accessor for the column field of hydra.ext.kusto.kql.ParseCommand
parseCommandColumn :: Typed.TypedTerm Kql.ParseCommand -> Typed.TypedTerm Kql.ColumnName
parseCommandColumn x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"),
        Model.projectionFieldName = (Model.Name "column")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the pairs field of hydra.ext.kusto.kql.ParseCommand
parseCommandPairs :: Typed.TypedTerm Kql.ParseCommand -> Typed.TypedTerm [Kql.KeyValuePair]
parseCommandPairs x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"),
        Model.projectionFieldName = (Model.Name "pairs")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.ParseCommand
parseCommandParseCommand :: Typed.TypedName Kql.ParseCommand
parseCommandParseCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.ParseCommand")

-- | DSL updater for the column field of hydra.ext.kusto.kql.ParseCommand
parseCommandWithColumn :: Typed.TypedTerm Kql.ParseCommand -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.ParseCommand
parseCommandWithColumn original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "pairs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"),
              Model.projectionFieldName = (Model.Name "pairs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the pairs field of hydra.ext.kusto.kql.ParseCommand
parseCommandWithPairs :: Typed.TypedTerm Kql.ParseCommand -> Typed.TypedTerm [Kql.KeyValuePair] -> Typed.TypedTerm Kql.ParseCommand
parseCommandWithPairs original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.ParseCommand"),
              Model.projectionFieldName = (Model.Name "column")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pairs"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for the hydra.ext.kusto.kql.PipelineExpression wrapper
pipelineExpression :: Typed.TypedTerm [Kql.TabularExpression] -> Typed.TypedTerm Kql.PipelineExpression
pipelineExpression x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.PipelineExpression"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.PipelineExpression
pipelineExpressionPipelineExpression :: Typed.TypedName Kql.PipelineExpression
pipelineExpressionPipelineExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.PipelineExpression")

-- | DSL constructor for hydra.ext.kusto.kql.PrintCommand
printCommand :: Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.PrintCommand
printCommand column expression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Typed.unTypedTerm column)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)}]}))

-- | DSL accessor for the column field of hydra.ext.kusto.kql.PrintCommand
printCommandColumn :: Typed.TypedTerm Kql.PrintCommand -> Typed.TypedTerm (Maybe Kql.ColumnName)
printCommandColumn x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"),
        Model.projectionFieldName = (Model.Name "column")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expression field of hydra.ext.kusto.kql.PrintCommand
printCommandExpression :: Typed.TypedTerm Kql.PrintCommand -> Typed.TypedTerm Kql.Expression
printCommandExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.PrintCommand
printCommandPrintCommand :: Typed.TypedName Kql.PrintCommand
printCommandPrintCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.PrintCommand")

-- | DSL updater for the column field of hydra.ext.kusto.kql.PrintCommand
printCommandWithColumn :: Typed.TypedTerm Kql.PrintCommand -> Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm Kql.PrintCommand
printCommandWithColumn original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the expression field of hydra.ext.kusto.kql.PrintCommand
printCommandWithExpression :: Typed.TypedTerm Kql.PrintCommand -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.PrintCommand
printCommandWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PrintCommand"),
              Model.projectionFieldName = (Model.Name "column")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.kusto.kql.Projection
projection :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm Kql.Projection
projection expression alias =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Typed.unTypedTerm alias)}]}))

-- | DSL accessor for the alias field of hydra.ext.kusto.kql.Projection
projectionAlias :: Typed.TypedTerm Kql.Projection -> Typed.TypedTerm (Maybe Kql.ColumnName)
projectionAlias x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"),
        Model.projectionFieldName = (Model.Name "alias")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expression field of hydra.ext.kusto.kql.Projection
projectionExpression :: Typed.TypedTerm Kql.Projection -> Typed.TypedTerm Kql.Expression
projectionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.Projection
projectionProjection :: Typed.TypedName Kql.Projection
projectionProjection = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Projection")

-- | DSL updater for the alias field of hydra.ext.kusto.kql.Projection
projectionWithAlias :: Typed.TypedTerm Kql.Projection -> Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm Kql.Projection
projectionWithAlias original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the expression field of hydra.ext.kusto.kql.Projection
projectionWithExpression :: Typed.TypedTerm Kql.Projection -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.Projection
projectionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.Projection"),
              Model.projectionFieldName = (Model.Name "alias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.kusto.kql.PropertyExpression
propertyExpression :: Typed.TypedTerm Kql.Expression -> Typed.TypedTerm String -> Typed.TypedTerm Kql.PropertyExpression
propertyExpression expression property =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "property"),
          Model.fieldTerm = (Typed.unTypedTerm property)}]}))

-- | DSL accessor for the expression field of hydra.ext.kusto.kql.PropertyExpression
propertyExpressionExpression :: Typed.TypedTerm Kql.PropertyExpression -> Typed.TypedTerm Kql.Expression
propertyExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the property field of hydra.ext.kusto.kql.PropertyExpression
propertyExpressionProperty :: Typed.TypedTerm Kql.PropertyExpression -> Typed.TypedTerm String
propertyExpressionProperty x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"),
        Model.projectionFieldName = (Model.Name "property")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.PropertyExpression
propertyExpressionPropertyExpression :: Typed.TypedName Kql.PropertyExpression
propertyExpressionPropertyExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.PropertyExpression")

-- | DSL updater for the expression field of hydra.ext.kusto.kql.PropertyExpression
propertyExpressionWithExpression :: Typed.TypedTerm Kql.PropertyExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.PropertyExpression
propertyExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "property"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"),
              Model.projectionFieldName = (Model.Name "property")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the property field of hydra.ext.kusto.kql.PropertyExpression
propertyExpressionWithProperty :: Typed.TypedTerm Kql.PropertyExpression -> Typed.TypedTerm String -> Typed.TypedTerm Kql.PropertyExpression
propertyExpressionWithProperty original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.PropertyExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "property"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for the hydra.ext.kusto.kql.Query wrapper
query :: Typed.TypedTerm Kql.TabularExpression -> Typed.TypedTerm Kql.Query
query x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.Query"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.Query
queryQuery :: Typed.TypedName Kql.Query
queryQuery = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.Query")

-- | DSL constructor for hydra.ext.kusto.kql.SearchCommand
searchCommand :: Typed.TypedTerm [Kql.TableName] -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.SearchCommand
searchCommand datasets pattern =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "datasets"),
          Model.fieldTerm = (Typed.unTypedTerm datasets)},
        Model.Field {
          Model.fieldName = (Model.Name "pattern"),
          Model.fieldTerm = (Typed.unTypedTerm pattern)}]}))

-- | DSL accessor for the datasets field of hydra.ext.kusto.kql.SearchCommand
searchCommandDatasets :: Typed.TypedTerm Kql.SearchCommand -> Typed.TypedTerm [Kql.TableName]
searchCommandDatasets x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"),
        Model.projectionFieldName = (Model.Name "datasets")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the pattern field of hydra.ext.kusto.kql.SearchCommand
searchCommandPattern :: Typed.TypedTerm Kql.SearchCommand -> Typed.TypedTerm Kql.Expression
searchCommandPattern x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"),
        Model.projectionFieldName = (Model.Name "pattern")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.SearchCommand
searchCommandSearchCommand :: Typed.TypedName Kql.SearchCommand
searchCommandSearchCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.SearchCommand")

-- | DSL updater for the datasets field of hydra.ext.kusto.kql.SearchCommand
searchCommandWithDatasets :: Typed.TypedTerm Kql.SearchCommand -> Typed.TypedTerm [Kql.TableName] -> Typed.TypedTerm Kql.SearchCommand
searchCommandWithDatasets original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "datasets"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "pattern"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"),
              Model.projectionFieldName = (Model.Name "pattern")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the pattern field of hydra.ext.kusto.kql.SearchCommand
searchCommandWithPattern :: Typed.TypedTerm Kql.SearchCommand -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.SearchCommand
searchCommandWithPattern original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "datasets"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SearchCommand"),
              Model.projectionFieldName = (Model.Name "datasets")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pattern"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.kusto.kql.SortBy
sortBy :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm (Maybe Kql.Order) -> Typed.TypedTerm Kql.SortBy
sortBy column order =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Typed.unTypedTerm column)},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Typed.unTypedTerm order)}]}))

-- | DSL accessor for the column field of hydra.ext.kusto.kql.SortBy
sortByColumn :: Typed.TypedTerm Kql.SortBy -> Typed.TypedTerm Kql.ColumnName
sortByColumn x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"),
        Model.projectionFieldName = (Model.Name "column")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the order field of hydra.ext.kusto.kql.SortBy
sortByOrder :: Typed.TypedTerm Kql.SortBy -> Typed.TypedTerm (Maybe Kql.Order)
sortByOrder x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"),
        Model.projectionFieldName = (Model.Name "order")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.SortBy
sortBySortBy :: Typed.TypedName Kql.SortBy
sortBySortBy = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.SortBy")

-- | DSL updater for the column field of hydra.ext.kusto.kql.SortBy
sortByWithColumn :: Typed.TypedTerm Kql.SortBy -> Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm Kql.SortBy
sortByWithColumn original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the order field of hydra.ext.kusto.kql.SortBy
sortByWithOrder :: Typed.TypedTerm Kql.SortBy -> Typed.TypedTerm (Maybe Kql.Order) -> Typed.TypedTerm Kql.SortBy
sortByWithOrder original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "column"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SortBy"),
              Model.projectionFieldName = (Model.Name "column")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.kusto.kql.SummarizeCommand
summarizeCommand :: Typed.TypedTerm [Kql.ColumnAssignment] -> Typed.TypedTerm [Kql.ColumnName] -> Typed.TypedTerm Kql.SummarizeCommand
summarizeCommand columns by =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columns"),
          Model.fieldTerm = (Typed.unTypedTerm columns)},
        Model.Field {
          Model.fieldName = (Model.Name "by"),
          Model.fieldTerm = (Typed.unTypedTerm by)}]}))

-- | DSL accessor for the by field of hydra.ext.kusto.kql.SummarizeCommand
summarizeCommandBy :: Typed.TypedTerm Kql.SummarizeCommand -> Typed.TypedTerm [Kql.ColumnName]
summarizeCommandBy x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"),
        Model.projectionFieldName = (Model.Name "by")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the columns field of hydra.ext.kusto.kql.SummarizeCommand
summarizeCommandColumns :: Typed.TypedTerm Kql.SummarizeCommand -> Typed.TypedTerm [Kql.ColumnAssignment]
summarizeCommandColumns x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"),
        Model.projectionFieldName = (Model.Name "columns")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.SummarizeCommand
summarizeCommandSummarizeCommand :: Typed.TypedName Kql.SummarizeCommand
summarizeCommandSummarizeCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.SummarizeCommand")

-- | DSL updater for the by field of hydra.ext.kusto.kql.SummarizeCommand
summarizeCommandWithBy :: Typed.TypedTerm Kql.SummarizeCommand -> Typed.TypedTerm [Kql.ColumnName] -> Typed.TypedTerm Kql.SummarizeCommand
summarizeCommandWithBy original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"),
      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.kusto.kql.SummarizeCommand"),
              Model.projectionFieldName = (Model.Name "columns")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "by"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the columns field of hydra.ext.kusto.kql.SummarizeCommand
summarizeCommandWithColumns :: Typed.TypedTerm Kql.SummarizeCommand -> Typed.TypedTerm [Kql.ColumnAssignment] -> Typed.TypedTerm Kql.SummarizeCommand
summarizeCommandWithColumns original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "columns"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "by"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.SummarizeCommand"),
              Model.projectionFieldName = (Model.Name "by")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.kusto.kql.TableName wrapper
tableName :: Typed.TypedTerm String -> Typed.TypedTerm Kql.TableName
tableName x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.kusto.kql.TableName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.TableName
tableNameTableName :: Typed.TypedName Kql.TableName
tableNameTableName = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.TableName")

-- | DSL injection for the command variant of hydra.ext.kusto.kql.TabularExpression
tabularExpressionCommand :: Typed.TypedTerm Kql.Command -> Typed.TypedTerm Kql.TabularExpression
tabularExpressionCommand x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.TabularExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "command"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the let variant of hydra.ext.kusto.kql.TabularExpression
tabularExpressionLet :: Typed.TypedTerm Kql.LetExpression -> Typed.TypedTerm Kql.TabularExpression
tabularExpressionLet x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.TabularExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "let"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the pipeline variant of hydra.ext.kusto.kql.TabularExpression
tabularExpressionPipeline :: Typed.TypedTerm Kql.PipelineExpression -> Typed.TypedTerm Kql.TabularExpression
tabularExpressionPipeline x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.TabularExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pipeline"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the table variant of hydra.ext.kusto.kql.TabularExpression
tabularExpressionTable :: Typed.TypedTerm Kql.TableName -> Typed.TypedTerm Kql.TabularExpression
tabularExpressionTable x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.TabularExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "table"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.kusto.kql.TabularExpression
tabularExpressionTabularExpression :: Typed.TypedName Kql.TabularExpression
tabularExpressionTabularExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.TabularExpression")

-- | DSL constructor for hydra.ext.kusto.kql.TopCommand
topCommand :: Typed.TypedTerm Int -> Typed.TypedTerm [Kql.SortBy] -> Typed.TypedTerm Kql.TopCommand
topCommand count sort =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "count"),
          Model.fieldTerm = (Typed.unTypedTerm count)},
        Model.Field {
          Model.fieldName = (Model.Name "sort"),
          Model.fieldTerm = (Typed.unTypedTerm sort)}]}))

-- | DSL accessor for the count field of hydra.ext.kusto.kql.TopCommand
topCommandCount :: Typed.TypedTerm Kql.TopCommand -> Typed.TypedTerm Int
topCommandCount x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"),
        Model.projectionFieldName = (Model.Name "count")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the sort field of hydra.ext.kusto.kql.TopCommand
topCommandSort :: Typed.TypedTerm Kql.TopCommand -> Typed.TypedTerm [Kql.SortBy]
topCommandSort x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"),
        Model.projectionFieldName = (Model.Name "sort")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.TopCommand
topCommandTopCommand :: Typed.TypedName Kql.TopCommand
topCommandTopCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.TopCommand")

-- | DSL updater for the count field of hydra.ext.kusto.kql.TopCommand
topCommandWithCount :: Typed.TypedTerm Kql.TopCommand -> Typed.TypedTerm Int -> Typed.TypedTerm Kql.TopCommand
topCommandWithCount original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "count"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "sort"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"),
              Model.projectionFieldName = (Model.Name "sort")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the sort field of hydra.ext.kusto.kql.TopCommand
topCommandWithSort :: Typed.TypedTerm Kql.TopCommand -> Typed.TypedTerm [Kql.SortBy] -> Typed.TypedTerm Kql.TopCommand
topCommandWithSort original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.TopCommand"),
      Model.recordFields = [
        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.kusto.kql.TopCommand"),
              Model.projectionFieldName = (Model.Name "count")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "sort"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL accessor for the body of hydra.ext.kusto.kql.ColumnName
unColumnName :: Typed.TypedTerm Kql.ColumnName -> Typed.TypedTerm String
unColumnName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.ColumnName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.kusto.kql.Datetime
unDatetime :: Typed.TypedTerm Kql.Datetime -> Typed.TypedTerm String
unDatetime x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.Datetime")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.kusto.kql.FunctionName
unFunctionName :: Typed.TypedTerm Kql.FunctionName -> Typed.TypedTerm String
unFunctionName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.FunctionName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.kusto.kql.PipelineExpression
unPipelineExpression :: Typed.TypedTerm Kql.PipelineExpression -> Typed.TypedTerm [Kql.TabularExpression]
unPipelineExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.PipelineExpression")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.kusto.kql.Query
unQuery :: Typed.TypedTerm Kql.Query -> Typed.TypedTerm Kql.TabularExpression
unQuery x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.Query")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.kusto.kql.TableName
unTableName :: Typed.TypedTerm Kql.TableName -> Typed.TypedTerm String
unTableName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.kusto.kql.TableName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.kusto.kql.UnaryExpression
unaryExpression :: Typed.TypedTerm Kql.UnaryOperator -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.UnaryExpression
unaryExpression operator expression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm operator)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)}]}))

-- | DSL accessor for the expression field of hydra.ext.kusto.kql.UnaryExpression
unaryExpressionExpression :: Typed.TypedTerm Kql.UnaryExpression -> Typed.TypedTerm Kql.Expression
unaryExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the operator field of hydra.ext.kusto.kql.UnaryExpression
unaryExpressionOperator :: Typed.TypedTerm Kql.UnaryExpression -> Typed.TypedTerm Kql.UnaryOperator
unaryExpressionOperator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"),
        Model.projectionFieldName = (Model.Name "operator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.UnaryExpression
unaryExpressionUnaryExpression :: Typed.TypedName Kql.UnaryExpression
unaryExpressionUnaryExpression = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.UnaryExpression")

-- | DSL updater for the expression field of hydra.ext.kusto.kql.UnaryExpression
unaryExpressionWithExpression :: Typed.TypedTerm Kql.UnaryExpression -> Typed.TypedTerm Kql.Expression -> Typed.TypedTerm Kql.UnaryExpression
unaryExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the operator field of hydra.ext.kusto.kql.UnaryExpression
unaryExpressionWithOperator :: Typed.TypedTerm Kql.UnaryExpression -> Typed.TypedTerm Kql.UnaryOperator -> Typed.TypedTerm Kql.UnaryExpression
unaryExpressionWithOperator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the not variant of hydra.ext.kusto.kql.UnaryOperator
unaryOperatorNot :: Typed.TypedTerm Kql.UnaryOperator
unaryOperatorNot =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "not"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.kusto.kql.UnaryOperator
unaryOperatorUnaryOperator :: Typed.TypedName Kql.UnaryOperator
unaryOperatorUnaryOperator = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.UnaryOperator")

-- | DSL constructor for hydra.ext.kusto.kql.UnionCommand
unionCommand :: Typed.TypedTerm [Kql.Parameter] -> Typed.TypedTerm (Maybe Kql.UnionKind) -> Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm [Kql.TableName] -> Typed.TypedTerm Kql.UnionCommand
unionCommand parameters kind withSource isFuzzy tables =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Typed.unTypedTerm kind)},
        Model.Field {
          Model.fieldName = (Model.Name "withSource"),
          Model.fieldTerm = (Typed.unTypedTerm withSource)},
        Model.Field {
          Model.fieldName = (Model.Name "isFuzzy"),
          Model.fieldTerm = (Typed.unTypedTerm isFuzzy)},
        Model.Field {
          Model.fieldName = (Model.Name "tables"),
          Model.fieldTerm = (Typed.unTypedTerm tables)}]}))

-- | DSL accessor for the isFuzzy field of hydra.ext.kusto.kql.UnionCommand
unionCommandIsFuzzy :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Bool)
unionCommandIsFuzzy x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
        Model.projectionFieldName = (Model.Name "isFuzzy")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the kind field of hydra.ext.kusto.kql.UnionCommand
unionCommandKind :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Kql.UnionKind)
unionCommandKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
        Model.projectionFieldName = (Model.Name "kind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameters field of hydra.ext.kusto.kql.UnionCommand
unionCommandParameters :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm [Kql.Parameter]
unionCommandParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the tables field of hydra.ext.kusto.kql.UnionCommand
unionCommandTables :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm [Kql.TableName]
unionCommandTables x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
        Model.projectionFieldName = (Model.Name "tables")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.kusto.kql.UnionCommand
unionCommandUnionCommand :: Typed.TypedName Kql.UnionCommand
unionCommandUnionCommand = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.UnionCommand")

-- | DSL updater for the isFuzzy field of hydra.ext.kusto.kql.UnionCommand
unionCommandWithIsFuzzy :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Kql.UnionCommand
unionCommandWithIsFuzzy original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withSource"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "withSource")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isFuzzy"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "tables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "tables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the kind field of hydra.ext.kusto.kql.UnionCommand
unionCommandWithKind :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Kql.UnionKind) -> Typed.TypedTerm Kql.UnionCommand
unionCommandWithKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "withSource"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "withSource")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isFuzzy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "isFuzzy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "tables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "tables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.kusto.kql.UnionCommand
unionCommandWithParameters :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm [Kql.Parameter] -> Typed.TypedTerm Kql.UnionCommand
unionCommandWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withSource"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "withSource")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isFuzzy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "isFuzzy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "tables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "tables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the withSource field of hydra.ext.kusto.kql.UnionCommand
unionCommandWithSource :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Kql.ColumnName)
unionCommandWithSource x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
        Model.projectionFieldName = (Model.Name "withSource")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the tables field of hydra.ext.kusto.kql.UnionCommand
unionCommandWithTables :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm [Kql.TableName] -> Typed.TypedTerm Kql.UnionCommand
unionCommandWithTables original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withSource"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "withSource")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isFuzzy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "isFuzzy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "tables"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the withSource field of hydra.ext.kusto.kql.UnionCommand
unionCommandWithWithSource :: Typed.TypedTerm Kql.UnionCommand -> Typed.TypedTerm (Maybe Kql.ColumnName) -> Typed.TypedTerm Kql.UnionCommand
unionCommandWithWithSource original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withSource"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "isFuzzy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "isFuzzy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "tables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionCommand"),
              Model.projectionFieldName = (Model.Name "tables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the inner variant of hydra.ext.kusto.kql.UnionKind
unionKindInner :: Typed.TypedTerm Kql.UnionKind
unionKindInner =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "inner"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the outer variant of hydra.ext.kusto.kql.UnionKind
unionKindOuter :: Typed.TypedTerm Kql.UnionKind
unionKindOuter =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.kusto.kql.UnionKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "outer"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.kusto.kql.UnionKind
unionKindUnionKind :: Typed.TypedName Kql.UnionKind
unionKindUnionKind = Typed.TypedName (Model.Name "hydra.ext.kusto.kql.UnionKind")