Dtld.hs

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

-- | An Azure Digital Twin Definition Language (DTLD) model. Based on:
-- |   https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#digital-twins-definition-language
-- | DTLD features which are not currently included in this model:
-- |   * geospatial schemas (https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#geospatial-schemas)
-- |   * semantic types and units (https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#semantic-types)
-- |   * model versioning (https://github.com/Azure/opendigitaltwins-dtdl/blob/master/DTDL/v2/dtdlv2.md#model-versioning)

module Hydra.Azure.Dtld where

import qualified Hydra.Core as Core
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci
import qualified Data.Set as S

-- | A Command describes a function or operation that can be performed on any digital twin.
data Command =
  Command {
    -- | This must be 'Command'
    commandType :: Iri,
    -- | The 'programming' name of the command. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.
    commandName :: String,
    -- | The ID of the command. If no @id is provided, the digital twin interface processor will assign one.
    commandId :: (Maybe Dtmi),
    -- | A comment for model authors
    commandComment :: (Maybe String),
    -- | A localizable description for display
    commandDescription :: (Maybe String),
    -- | A localizable name for display
    commandDisplayName :: (Maybe String),
    -- | This property is deprecated. Either value, synchronous or asynchronous, has the same meaning: a command that starts execution within a configurable time and that completes execution within a configurable time.
    commandCommandType :: (Maybe CommandType),
    -- | A description of the input to the Command
    commandRequest :: (Maybe CommandPayload),
    -- | A description of the output of the Command
    commandResponse :: (Maybe CommandPayload)}
  deriving (Eq, Ord, Read, Show)

_Command = Core.Name "hydra.azure.dtld.Command"

_Command_type = Core.Name "type"

_Command_name = Core.Name "name"

_Command_id = Core.Name "id"

_Command_comment = Core.Name "comment"

_Command_description = Core.Name "description"

_Command_displayName = Core.Name "displayName"

_Command_commandType = Core.Name "commandType"

_Command_request = Core.Name "request"

_Command_response = Core.Name "response"

-- | A CommandPayload describes the inputs to or the outputs from a Command.
data CommandPayload =
  CommandPayload {
    -- | The 'programming' name of the payload. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.
    commandPayloadName :: String,
    -- | The data type of the payload
    commandPayloadSchema :: Schema,
    -- | The ID of the payload. If no @id is provided, the digital twin interface processor will assign one.
    commandPayloadId :: (Maybe Dtmi),
    -- | A comment for model authors
    commandPayloadComment :: (Maybe String),
    -- | A localizable description for display
    commandPayloadDescription :: (Maybe String),
    -- | A localizable name for display
    commandPayloadDisplayName :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_CommandPayload = Core.Name "hydra.azure.dtld.CommandPayload"

_CommandPayload_name = Core.Name "name"

_CommandPayload_schema = Core.Name "schema"

_CommandPayload_id = Core.Name "id"

_CommandPayload_comment = Core.Name "comment"

_CommandPayload_description = Core.Name "description"

_CommandPayload_displayName = Core.Name "displayName"

-- | CommandType is deprecated. Either value, synchronous or asynchronous, has the same meaning: a command that starts execution within a configurable time and that completes execution within a configurable time.
data CommandType =
  CommandTypeSynchronous |
  CommandTypeAsynchronous
  deriving (Eq, Ord, Read, Show)

_CommandType = Core.Name "hydra.azure.dtld.CommandType"

_CommandType_synchronous = Core.Name "synchronous"

_CommandType_asynchronous = Core.Name "asynchronous"

-- | Components enable interfaces to be composed of other interfaces. Components are different from relationships because they describe contents that are directly part of the interface. (A relationship describes a link between two interfaces.)
data Component =
  Component {
    -- | This must be 'Component'
    componentType :: Iri,
    -- | The 'programming' name of the component. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.
    componentName :: String,
    -- | The data type of the component
    componentSchema :: Interface,
    -- | The ID of the component. If no @id is provided, the digital twin interface processor will assign one.
    componentId :: (Maybe Dtmi),
    -- | A comment for model authors
    componentComment :: (Maybe String),
    -- | A localizable description for display
    componentDescription :: (Maybe String),
    -- | A localizable name for display
    componentDisplayName :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_Component = Core.Name "hydra.azure.dtld.Component"

_Component_type = Core.Name "type"

_Component_name = Core.Name "name"

_Component_schema = Core.Name "schema"

_Component_id = Core.Name "id"

_Component_comment = Core.Name "comment"

_Component_description = Core.Name "description"

_Component_displayName = Core.Name "displayName"

-- | A digital twin model identifier
newtype Dtmi =
  Dtmi {
    unDtmi :: String}
  deriving (Eq, Ord, Read, Show)

_Dtmi = Core.Name "hydra.azure.dtld.Dtmi"

-- | An EnumValue describes an element of an Enum.
data EnumValue =
  EnumValue {
    -- | The 'programming' name of the enum value. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.
    enumValueName :: String,
    -- | The on-the-wire value that maps to the EnumValue. EnumValue may be either an integer or a string and must be unique for all enum values in this enum.
    enumValueEnumValue :: IntegerOrString,
    -- | The ID of the enum value. If no @id is provided, the digital twin interface processor will assign one.
    enumValueId :: (Maybe Dtmi),
    -- | A comment for model authors
    enumValueComment :: (Maybe String),
    -- | A localizable description for display
    enumValueDescription :: (Maybe String),
    -- | A localizable name for display
    enumValueDisplayName :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_EnumValue = Core.Name "hydra.azure.dtld.EnumValue"

_EnumValue_name = Core.Name "name"

_EnumValue_enumValue = Core.Name "enumValue"

_EnumValue_id = Core.Name "id"

_EnumValue_comment = Core.Name "comment"

_EnumValue_description = Core.Name "description"

_EnumValue_displayName = Core.Name "displayName"

-- | A Field describes a field in an Object.
data Field =
  Field {
    -- | The 'programming' name of the field. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.
    fieldName :: String,
    -- | The data type of the field
    fieldSchema :: Schema,
    -- | The ID of the field. If no @id is provided, the digital twin interface processor will assign one.
    fieldId :: (Maybe Dtmi),
    -- | A comment for model authors
    fieldComment :: (Maybe String),
    -- | A localizable description for display
    fieldDescription :: (Maybe String),
    -- | A localizable name for display
    fieldDisplayName :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_Field = Core.Name "hydra.azure.dtld.Field"

_Field_name = Core.Name "name"

_Field_schema = Core.Name "schema"

_Field_id = Core.Name "id"

_Field_comment = Core.Name "comment"

_Field_description = Core.Name "description"

_Field_displayName = Core.Name "displayName"

-- | A value which may be either an integer or a string
data IntegerOrString =
  IntegerOrStringInteger Int |
  IntegerOrStringString String
  deriving (Eq, Ord, Read, Show)

_IntegerOrString = Core.Name "hydra.azure.dtld.IntegerOrString"

_IntegerOrString_integer = Core.Name "integer"

_IntegerOrString_string = Core.Name "string"

-- | An Interface describes the contents (Telemetry, Properties, Commands, Relationships, and Components) of any digital twin.
data Interface =
  Interface {
    -- | A digital twin model identifier for the interface
    interfaceId :: Dtmi,
    -- | This must be 'Interface'
    interfaceType :: Iri,
    -- | The context to use when processing this interface. For this version, it must be set to 'dtmi:dtdl:context;2'
    interfaceContext :: Iri,
    -- | A comment for model authors
    interfaceComment :: (Maybe String),
    -- | A set of objects that define the contents (Telemetry, Properties, Commands, Relationships, and/or Components) of this interface
    interfaceContents :: (Maybe (S.Set InterfaceContents)),
    -- | A localizable description for display
    interfaceDescription :: (Maybe String),
    -- | A localizable name for display
    interfaceDisplayName :: (Maybe String),
    -- | A set of DTMIs that refer to interfaces this interface inherits from. Interfaces can inherit from multiple interfaces.
    interfaceExtends :: (Maybe (S.Set Interface)),
    -- | A set of IRIs or objects that refer to the reusable schemas within this interface.
    interfaceSchemas :: (Maybe (S.Set SchemaInterface))}
  deriving (Eq, Ord, Read, Show)

_Interface = Core.Name "hydra.azure.dtld.Interface"

_Interface_id = Core.Name "id"

_Interface_type = Core.Name "type"

_Interface_context = Core.Name "context"

_Interface_comment = Core.Name "comment"

_Interface_contents = Core.Name "contents"

_Interface_description = Core.Name "description"

_Interface_displayName = Core.Name "displayName"

_Interface_extends = Core.Name "extends"

_Interface_schemas = Core.Name "schemas"

-- | One of the kinds of content an Interface may contain: a Command, Component, Property, Relationship, or Telemetry
data InterfaceContents =
  InterfaceContentsCommand Command |
  InterfaceContentsComponent Component |
  InterfaceContentsProperty Property |
  InterfaceContentsRelationship Relationship |
  InterfaceContentsTelemetry Telemetry
  deriving (Eq, Ord, Read, Show)

_InterfaceContents = Core.Name "hydra.azure.dtld.InterfaceContents"

_InterfaceContents_command = Core.Name "command"

_InterfaceContents_component = Core.Name "component"

_InterfaceContents_property = Core.Name "property"

_InterfaceContents_relationship = Core.Name "relationship"

_InterfaceContents_telemetry = Core.Name "telemetry"

-- | An Internationalized Resource Identifier
newtype Iri =
  Iri {
    unIri :: String}
  deriving (Eq, Ord, Read, Show)

_Iri = Core.Name "hydra.azure.dtld.Iri"

-- | A MapKey describes the key in a Map. The schema of a MapKey must be string.
data MapKey =
  MapKey {
    -- | The 'programming' name of the map's key. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.
    mapKeyName :: String,
    -- | The data type of the map's key
    mapKeySchema :: Schema,
    -- | The ID of the map key. If no @id is provided, the digital twin interface processor will assign one.
    mapKeyId :: (Maybe Dtmi),
    -- | A comment for model authors
    mapKeyComment :: (Maybe String),
    -- | A localizable description for display
    mapKeyDescription :: (Maybe String),
    -- | A localizable name for display
    mapKeyDisplayName :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_MapKey = Core.Name "hydra.azure.dtld.MapKey"

_MapKey_name = Core.Name "name"

_MapKey_schema = Core.Name "schema"

_MapKey_id = Core.Name "id"

_MapKey_comment = Core.Name "comment"

_MapKey_description = Core.Name "description"

_MapKey_displayName = Core.Name "displayName"

-- | A MapValue describes the values in a Map.
data MapValue =
  MapValue {
    -- | The 'programming' name of the map's value. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.
    mapValueName :: String,
    -- | The data type of the map's values
    mapValueSchema :: Schema,
    -- | The ID of the map value. If no @id is provided, the digital twin interface processor will assign one.
    mapValueId :: (Maybe Dtmi),
    -- | A comment for model authors
    mapValueComment :: (Maybe String),
    -- | A localizable description for display
    mapValueDescription :: (Maybe String),
    -- | A localizable name for display
    mapValueDisplayName :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_MapValue = Core.Name "hydra.azure.dtld.MapValue"

_MapValue_name = Core.Name "name"

_MapValue_schema = Core.Name "schema"

_MapValue_id = Core.Name "id"

_MapValue_comment = Core.Name "comment"

_MapValue_description = Core.Name "description"

_MapValue_displayName = Core.Name "displayName"

-- | A Property describes the read-only and read/write state of any digital twin. For example, a device serial number may be a read-only property, the desired temperature on a thermostat may be a read-write property; and the name of a room may be a read-write property.
data Property =
  Property {
    -- | This must at least be 'Property'. It can also include a semantic type.
    propertyType :: Iri,
    -- | The 'programming' name of the property. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$..
    propertyName :: String,
    -- | The data type of the Property
    propertySchema :: Schema,
    -- | The ID of the property. If no @id is provided, the digital twin interface processor will assign one.
    propertyId :: (Maybe Dtmi),
    -- | A comment for model authors
    propertyComment :: (Maybe String),
    -- | A localizable description for display
    propertyDescription :: (Maybe String),
    -- | A localizable name for display
    propertyDisplayName :: (Maybe String),
    -- | The unit type of the property. A semantic type is required for the unit property to be available.
    propertyUnit :: (Maybe Unit),
    -- | A boolean value that indicates whether the property is writable by an external source, such as an application, or not. The default value is false (read-only).
    propertyWritable :: (Maybe Bool)}
  deriving (Eq, Ord, Read, Show)

_Property = Core.Name "hydra.azure.dtld.Property"

_Property_type = Core.Name "type"

_Property_name = Core.Name "name"

_Property_schema = Core.Name "schema"

_Property_id = Core.Name "id"

_Property_comment = Core.Name "comment"

_Property_description = Core.Name "description"

_Property_displayName = Core.Name "displayName"

_Property_unit = Core.Name "unit"

_Property_writable = Core.Name "writable"

-- | A Relationship describes a link to another digital twin and enables graphs of digital twins to be created. Relationships are different from Components because they describe a link to a separate digital twin.
data Relationship =
  Relationship {
    -- | This must be 'Relationship'
    relationshipType :: Iri,
    -- | The 'programming' name of the relationship. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$.
    relationshipName :: String,
    -- | The ID of the relationship description. If no @id is provided, the digital twin interface processor will assign one.
    relationshipId :: (Maybe Dtmi),
    -- | A comment for model authors
    relationshipComment :: (Maybe String),
    -- | A localizable description for display
    relationshipDescription :: (Maybe String),
    -- | A localizable name for display
    relationshipDisplayName :: (Maybe String),
    -- | The maximum multiplicity for the target of the relationship. The default value is infinite (there may be an unlimited number of relationship instances for this relationship).
    relationshipMaxMultiplicity :: (Maybe Int),
    -- | The minimum multiplicity for the target of the relationship. The default value is 0 (this relationship is permitted to have no instances). In DTDL v2, minMultiplicity must always be 0.
    relationshipMinMultiplicity :: (Maybe Int),
    -- | A set of Properties that define relationship-specific state
    relationshipProperties :: (Maybe (S.Set Property)),
    -- | An interface ID. The default value (when target is not specified) is that the target may be any interface.
    relationshipTarget :: (Maybe Interface),
    -- | A boolean value that indicates whether the relationship is writable by an external source, such as an application, or not. The default value is false (read-only).
    relationshipWritable :: (Maybe Bool)}
  deriving (Eq, Ord, Read, Show)

_Relationship = Core.Name "hydra.azure.dtld.Relationship"

_Relationship_type = Core.Name "type"

_Relationship_name = Core.Name "name"

_Relationship_id = Core.Name "id"

_Relationship_comment = Core.Name "comment"

_Relationship_description = Core.Name "description"

_Relationship_displayName = Core.Name "displayName"

_Relationship_maxMultiplicity = Core.Name "maxMultiplicity"

_Relationship_minMultiplicity = Core.Name "minMultiplicity"

_Relationship_properties = Core.Name "properties"

_Relationship_target = Core.Name "target"

_Relationship_writable = Core.Name "writable"

-- | Schemas are used to describe the on-the-wire or serialized format of the data in a digital twin interface. A full set of primitive data types are provided, along with support for a variety of complex schemas in the forms of Arrays, Enums, Maps, and Objects. Schemas described through digital twin's schema definition language are compatible with popular serialization formats, including JSON, Avro, and Protobuf.
data Schema =
  SchemaPrimitive_ SchemaPrimitive |
  SchemaComplex_ SchemaComplex
  deriving (Eq, Ord, Read, Show)

_Schema = Core.Name "hydra.azure.dtld.Schema"

_Schema_primitive = Core.Name "primitive"

_Schema_complex = Core.Name "complex"

-- | An Array describes an indexable data type where each element is of the same schema. An Array elements' schema can itself be a primitive or complex schema.
data SchemaArray =
  SchemaArray {
    -- | This must be 'Array'
    schemaArrayType :: Iri,
    -- | The data type of the array elements
    schemaArrayElementSchema :: Schema,
    -- | The ID of the array. If no @id is provided, the digital twin interface processor will assign one.
    schemaArrayId :: (Maybe Dtmi),
    -- | A comment for model authors
    schemaArrayComment :: (Maybe String),
    -- | A localizable description for display
    schemaArrayDescription :: (Maybe String),
    -- | A localizable name for display
    schemaArrayDisplayName :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_SchemaArray = Core.Name "hydra.azure.dtld.SchemaArray"

_SchemaArray_type = Core.Name "type"

_SchemaArray_elementSchema = Core.Name "elementSchema"

_SchemaArray_id = Core.Name "id"

_SchemaArray_comment = Core.Name "comment"

_SchemaArray_description = Core.Name "description"

_SchemaArray_displayName = Core.Name "displayName"

-- | Complex schemas are designed for supporting complex data types made up of primitive data types. Currently the following complex schemas are provided: Array, Enum, Map, and Object. A complex schema can be specified directly as the value in a schema statement or described in the interface schemas set and referenced in the schema statement.
data SchemaComplex =
  SchemaComplexArray SchemaArray |
  SchemaComplexEnum SchemaEnum |
  SchemaComplexMap SchemaMap |
  SchemaComplexObject SchemaObject
  deriving (Eq, Ord, Read, Show)

_SchemaComplex = Core.Name "hydra.azure.dtld.SchemaComplex"

_SchemaComplex_array = Core.Name "array"

_SchemaComplex_enum = Core.Name "enum"

_SchemaComplex_map = Core.Name "map"

_SchemaComplex_object = Core.Name "object"

-- | An Enum describes a data type with a set of named labels that map to values. The values in an Enum can be either integers or strings, but the labels are always strings.
data SchemaEnum =
  SchemaEnum {
    -- | Enum
    schemaEnumType :: Iri,
    -- | A set of enum value and label mappings
    schemaEnumEnumValues :: [EnumValue],
    -- | The data type for the enum values. All enum values must be of the same type.
    schemaEnumValueSchema :: IntegerOrString,
    -- | The ID of the enum. If no @id is provided, the digital twin interface processor will assign one.
    schemaEnumId :: (Maybe Dtmi),
    -- | A comment for model authors
    schemaEnumComment :: (Maybe String),
    -- | A localizable description for display
    schemaEnumDescription :: (Maybe String),
    -- | A localizable name for display
    schemaEnumDisplayName :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_SchemaEnum = Core.Name "hydra.azure.dtld.SchemaEnum"

_SchemaEnum_type = Core.Name "type"

_SchemaEnum_enumValues = Core.Name "enumValues"

_SchemaEnum_valueSchema = Core.Name "valueSchema"

_SchemaEnum_id = Core.Name "id"

_SchemaEnum_comment = Core.Name "comment"

_SchemaEnum_description = Core.Name "description"

_SchemaEnum_displayName = Core.Name "displayName"

-- | Within an interface definition, complex schemas may be defined for reusability across Telemetry, Properties, and Commands. This is designed to promote readability and improved maintenance because schemas that are reused can be defined once (per interface). Interface schemas are defined in the schemas property of an interface.
data SchemaInterface =
  SchemaInterface {
    -- | The globally unique identifier for the schema
    schemaInterfaceId :: Dtmi,
    -- | The type of complex schema. This must refer to one of the complex schema classes (Array, Enum, Map, or Object).
    schemaInterfaceType :: SchemaInterfaceType,
    -- | A comment for model authors
    schemaInterfaceComment :: (Maybe String),
    -- | A localizable description for display
    schemaInterfaceDescription :: (Maybe String),
    -- | A localizable name for display
    schemaInterfaceDisplayName :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_SchemaInterface = Core.Name "hydra.azure.dtld.SchemaInterface"

_SchemaInterface_id = Core.Name "id"

_SchemaInterface_type = Core.Name "type"

_SchemaInterface_comment = Core.Name "comment"

_SchemaInterface_description = Core.Name "description"

_SchemaInterface_displayName = Core.Name "displayName"

-- | The type of a reusable interface schema: Array, Enum, Map, or Object
data SchemaInterfaceType =
  SchemaInterfaceTypeArray SchemaArray |
  SchemaInterfaceTypeEnum SchemaEnum |
  SchemaInterfaceTypeMap SchemaMap |
  SchemaInterfaceTypeObject SchemaObject
  deriving (Eq, Ord, Read, Show)

_SchemaInterfaceType = Core.Name "hydra.azure.dtld.SchemaInterfaceType"

_SchemaInterfaceType_array = Core.Name "array"

_SchemaInterfaceType_enum = Core.Name "enum"

_SchemaInterfaceType_map = Core.Name "map"

_SchemaInterfaceType_object = Core.Name "object"

-- | A Map describes a data type of key-value pairs where the values share the same schema. The key in a Map must be a string. The values in a Map can be any schema.
data SchemaMap =
  SchemaMap {
    -- | Map
    schemaMapType :: Iri,
    -- | A description of the keys in the map
    schemaMapMapKey :: MapKey,
    -- | A description of the values in the map
    schemaMapMapValue :: MapValue,
    -- | The ID of the map. If no @id is provided, the digital twin interface processor will assign one.
    schemaMapId :: (Maybe Dtmi),
    -- | A comment for model authors
    schemaMapComment :: (Maybe String),
    -- | A localizable description for display
    schemaMapDescription :: (Maybe String),
    -- | A localizable name for display
    schemaMapDisplayName :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_SchemaMap = Core.Name "hydra.azure.dtld.SchemaMap"

_SchemaMap_type = Core.Name "type"

_SchemaMap_mapKey = Core.Name "mapKey"

_SchemaMap_mapValue = Core.Name "mapValue"

_SchemaMap_id = Core.Name "id"

_SchemaMap_comment = Core.Name "comment"

_SchemaMap_description = Core.Name "description"

_SchemaMap_displayName = Core.Name "displayName"

-- | An Object describes a data type made up of named fields (like a struct in C). The fields in an Object map can be primitive or complex schemas.
data SchemaObject =
  SchemaObject {
    -- | Object
    schemaObjectType :: Iri,
    -- | A set of field descriptions, one for each field in the Object
    schemaObjectFields :: (S.Set Field),
    -- | The ID of the object. If no @id is provided, the digital twin interface processor will assign one.
    schemaObjectId :: (Maybe Dtmi),
    -- | A comment for model authors
    schemaObjectComment :: (Maybe String),
    -- | A localizable description for display
    schemaObjectDescription :: (Maybe String),
    -- | A localizable name for display
    schemaObjectDisplayName :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_SchemaObject = Core.Name "hydra.azure.dtld.SchemaObject"

_SchemaObject_type = Core.Name "type"

_SchemaObject_fields = Core.Name "fields"

_SchemaObject_id = Core.Name "id"

_SchemaObject_comment = Core.Name "comment"

_SchemaObject_description = Core.Name "description"

_SchemaObject_displayName = Core.Name "displayName"

-- | A full set of primitive data types are provided and can be specified directly as the value in a schema statement in a digital twin interface.
data SchemaPrimitive =
  -- | A boolean value
  SchemaPrimitiveBoolean |
  -- | A full-date as defined in section 5.6 of RFC 3339
  SchemaPrimitiveDate |
  -- | A date-time as defined in RFC 3339
  SchemaPrimitiveDateTime |
  -- | An IEEE 8-byte floating point
  SchemaPrimitiveDouble |
  -- | A duration in ISO 8601 format
  SchemaPrimitiveDuration |
  -- | An IEEE 4-byte floating point
  SchemaPrimitiveFloat |
  -- | A signed 4-byte integer
  SchemaPrimitiveInteger |
  -- | A signed 8-byte integer
  SchemaPrimitiveLong |
  -- | A UTF8 string
  SchemaPrimitiveString |
  -- | A full-time as defined in section 5.6 of RFC 3339
  SchemaPrimitiveTime
  deriving (Eq, Ord, Read, Show)

_SchemaPrimitive = Core.Name "hydra.azure.dtld.SchemaPrimitive"

_SchemaPrimitive_boolean = Core.Name "boolean"

_SchemaPrimitive_date = Core.Name "date"

_SchemaPrimitive_dateTime = Core.Name "dateTime"

_SchemaPrimitive_double = Core.Name "double"

_SchemaPrimitive_duration = Core.Name "duration"

_SchemaPrimitive_float = Core.Name "float"

_SchemaPrimitive_integer = Core.Name "integer"

_SchemaPrimitive_long = Core.Name "long"

_SchemaPrimitive_string = Core.Name "string"

_SchemaPrimitive_time = Core.Name "time"

-- | Telemetry describes the data emitted by any digital twin, whether the data is a regular stream of sensor readings or a computed stream of data, such as occupancy, or an occasional error or information message.
data Telemetry =
  Telemetry {
    -- | This must be at least 'Telemetry'. It can also include a semantic type
    telemetryType :: Iri,
    -- | The 'programming' name of the telemetry. The name may only contain the characters a-z, A-Z, 0-9, and underscore, and must match this regular expression ^[a-zA-Z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$..
    telemetryName :: String,
    -- | The data type of the Telemetry
    telemetrySchema :: Schema,
    -- | The ID of the telemetry. If no @id is provided, the digital twin interface processor will assign one.
    telemetryId :: (Maybe Dtmi),
    -- | A comment for model authors
    telemetryComment :: (Maybe String),
    -- | A localizable description for display
    telemetryDescription :: (Maybe String),
    -- | A localizable name for display
    telemetryDisplayName :: (Maybe String),
    -- | The unit type of the Telemetry. A semantic type is required for the unit property to be available.
    telemetryUnit :: (Maybe Unit)}
  deriving (Eq, Ord, Read, Show)

_Telemetry = Core.Name "hydra.azure.dtld.Telemetry"

_Telemetry_type = Core.Name "type"

_Telemetry_name = Core.Name "name"

_Telemetry_schema = Core.Name "schema"

_Telemetry_id = Core.Name "id"

_Telemetry_comment = Core.Name "comment"

_Telemetry_description = Core.Name "description"

_Telemetry_displayName = Core.Name "displayName"

_Telemetry_unit = Core.Name "unit"

-- | The unit type of a Property or Telemetry value, available when a semantic type is present
newtype Unit =
  Unit {
    unUnit :: ()}
  deriving (Eq, Ord, Read, Show)

_Unit = Core.Name "hydra.azure.dtld.Unit"