diff --git a/build/yang-files/ietf-hardware@2018-03-13.yang b/build/yang-files/ietf-hardware@2018-03-13.yang
new file mode 100644
index 0000000..4f984b6
--- /dev/null
+++ b/build/yang-files/ietf-hardware@2018-03-13.yang
@@ -0,0 +1,1194 @@
+module ietf-hardware {
+  yang-version 1.1;
+  namespace "urn:ietf:params:xml:ns:yang:ietf-hardware";
+  prefix hw;
+
+  import ietf-inet-types {
+    prefix inet;
+  }
+  import ietf-yang-types {
+    prefix yang;
+  }
+  import iana-hardware {
+    prefix ianahw;
+  }
+
+  organization
+    "IETF NETMOD (Network Modeling) Working Group";
+
+  contact
+    "WG Web:   <https://datatracker.ietf.org/wg/netmod/>
+     WG List:  <mailto:netmod@ietf.org>
+
+     Editor:   Andy Bierman
+               <mailto:andy@yumaworks.com>
+
+     Editor:   Martin Bjorklund
+               <mailto:mbj@tail-f.com>
+
+     Editor:   Jie Dong
+               <mailto:jie.dong@huawei.com>
+
+     Editor:   Dan Romascanu
+               <mailto:dromasca@gmail.com>";
+
+  description
+    "This module contains a collection of YANG definitions for
+     managing hardware.
+
+     This data model is designed for the Network Management Datastore
+     Architecture (NMDA) defined in RFC 8342.
+     Copyright (c) 2018 IETF Trust and the persons identified as
+     authors of the code.  All rights reserved.
+
+     Redistribution and use in source and binary forms, with or
+     without modification, is permitted pursuant to, and subject
+     to the license terms contained in, the Simplified BSD License
+     set forth in Section 4.c of the IETF Trust's Legal Provisions
+     Relating to IETF Documents
+     (https://trustee.ietf.org/license-info).
+
+     This version of this YANG module is part of RFC 8348; see
+     the RFC itself for full legal notices.";
+
+  revision 2018-03-13 {
+    description
+      "Initial revision.";
+    reference
+      "RFC 8348: A YANG Data Model for Hardware Management";
+  }
+
+  /*
+   * Features
+   */
+
+  feature entity-mib {
+    description
+      "This feature indicates that the device implements
+       the ENTITY-MIB.";
+    reference
+      "RFC 6933: Entity MIB (Version 4)";
+  }
+
+  feature hardware-state {
+    description
+      "Indicates that ENTITY-STATE-MIB objects are supported";
+    reference
+      "RFC 4268: Entity State MIB";
+  }
+
+  feature hardware-sensor {
+    description
+      "Indicates that ENTITY-SENSOR-MIB objects are supported";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base";
+  }
+
+  /*
+   * Typedefs
+   */
+
+  typedef admin-state {
+    type enumeration {
+      enum unknown {
+        value 1;
+        description
+          "The resource is unable to report administrative state.";
+      }
+      enum locked {
+        value 2;
+        description
+          "The resource is administratively prohibited from use.";
+      }
+      enum shutting-down {
+        value 3;
+        description
+          "The resource usage is administratively limited to current
+           instances of use.";
+      }
+      enum unlocked {
+        value 4;
+        description
+          "The resource is not administratively prohibited from
+           use.";
+      }
+    }
+    description
+      "Represents the various possible administrative states.";
+    reference
+      "RFC 4268: Entity State MIB - EntityAdminState";
+  }
+
+  typedef oper-state {
+    type enumeration {
+      enum unknown {
+        value 1;
+        description
+          "The resource is unable to report its operational state.";
+      }
+      enum disabled {
+        value 2;
+        description
+          "The resource is totally inoperable.";
+      }
+      enum enabled {
+        value 3;
+
+        description
+          "The resource is partially or fully operable.";
+      }
+      enum testing {
+        value 4;
+        description
+          "The resource is currently being tested and cannot
+           therefore report whether or not it is operational.";
+      }
+    }
+    description
+      "Represents the possible values of operational states.";
+    reference
+      "RFC 4268: Entity State MIB - EntityOperState";
+  }
+
+  typedef usage-state {
+    type enumeration {
+      enum unknown {
+        value 1;
+        description
+          "The resource is unable to report usage state.";
+      }
+      enum idle {
+        value 2;
+        description
+          "The resource is servicing no users.";
+      }
+      enum active {
+        value 3;
+        description
+          "The resource is currently in use, and it has sufficient
+           spare capacity to provide for additional users.";
+      }
+      enum busy {
+        value 4;
+        description
+          "The resource is currently in use, but it currently has no
+           spare capacity to provide for additional users.";
+      }
+    }
+    description
+      "Represents the possible values of usage states.";
+    reference
+      "RFC 4268: Entity State MIB -  EntityUsageState";
+  }
+
+  typedef alarm-state {
+    type bits {
+      bit unknown {
+        position 0;
+        description
+          "The resource is unable to report alarm state.";
+      }
+      bit under-repair {
+        position 1;
+        description
+          "The resource is currently being repaired, which, depending
+           on the implementation, may make the other values in this
+           bit string not meaningful.";
+      }
+      bit critical {
+        position 2;
+        description
+          "One or more critical alarms are active against the
+           resource.";
+      }
+      bit major {
+        position 3;
+        description
+          "One or more major alarms are active against the
+           resource.";
+      }
+      bit minor {
+        position 4;
+        description
+          "One or more minor alarms are active against the
+           resource.";
+      }
+      bit warning {
+        position 5;
+        description
+          "One or more warning alarms are active against the
+           resource.";
+      }
+      bit indeterminate {
+        position 6;
+        description
+          "One or more alarms of whose perceived severity cannot be
+           determined are active against this resource.";
+      }
+    }
+    description
+      "Represents the possible values of alarm states.  An alarm is a
+       persistent indication of an error or warning condition.
+
+       When no bits of this attribute are set, then no active alarms
+       are known against this component and it is not under repair.";
+    reference
+      "RFC 4268: Entity State MIB - EntityAlarmStatus";
+  }
+
+  typedef standby-state {
+    type enumeration {
+      enum unknown {
+        value 1;
+        description
+          "The resource is unable to report standby state.";
+      }
+      enum hot-standby {
+        value 2;
+        description
+          "The resource is not providing service, but it will be
+           immediately able to take over the role of the resource to
+           be backed up, without the need for initialization
+           activity, and will contain the same information as the
+           resource to be backed up.";
+      }
+      enum cold-standby {
+        value 3;
+        description
+          "The resource is to back up another resource, but it will
+           not be immediately able to take over the role of a
+           resource to be backed up and will require some
+           initialization activity.";
+      }
+      enum providing-service {
+        value 4;
+        description
+          "The resource is providing service.";
+      }
+    }
+    description
+      "Represents the possible values of standby states.";
+    reference
+      "RFC 4268: Entity State MIB - EntityStandbyStatus";
+  }
+
+  typedef sensor-value-type {
+    type enumeration {
+      enum other {
+        value 1;
+        description
+          "A measure other than those listed below.";
+      }
+      enum unknown {
+        value 2;
+        description
+          "An unknown measurement or arbitrary, relative numbers";
+      }
+      enum volts-AC {
+        value 3;
+        description
+          "A measure of electric potential (alternating current).";
+      }
+      enum volts-DC {
+        value 4;
+        description
+          "A measure of electric potential (direct current).";
+      }
+      enum amperes {
+        value 5;
+        description
+          "A measure of electric current.";
+      }
+      enum watts {
+        value 6;
+        description
+          "A measure of power.";
+      }
+      enum hertz {
+        value 7;
+        description
+          "A measure of frequency.";
+      }
+      enum celsius {
+        value 8;
+        description
+          "A measure of temperature.";
+      }
+      enum percent-RH {
+        value 9;
+        description
+          "A measure of percent relative humidity.";
+      }
+      enum rpm {
+        value 10;
+        description
+          "A measure of shaft revolutions per minute.";
+      }
+      enum cmm {
+        value 11;
+        description
+          "A measure of cubic meters per minute (airflow).";
+      }
+      enum truth-value {
+        value 12;
+        description
+          "Value is one of 1 (true) or 2 (false)";
+      }
+    }
+    description
+      "A node using this data type represents the sensor measurement
+       data type associated with a physical sensor value.  The actual
+       data units are determined by examining a node of this type
+       together with the associated sensor-value-scale node.
+
+       A node of this type SHOULD be defined together with nodes of
+       type sensor-value-scale and type sensor-value-precision.
+       These three types are used to identify the semantics of a node
+       of type sensor-value.";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base -
+                 EntitySensorDataType";
+  }
+
+  typedef sensor-value-scale {
+    type enumeration {
+      enum yocto {
+        value 1;
+        description
+          "Data scaling factor of 10^-24.";
+      }
+      enum zepto {
+        value 2;
+        description
+          "Data scaling factor of 10^-21.";
+      }
+      enum atto {
+        value 3;
+        description
+          "Data scaling factor of 10^-18.";
+      }
+      enum femto {
+        value 4;
+        description
+          "Data scaling factor of 10^-15.";
+      }
+      enum pico {
+        value 5;
+        description
+          "Data scaling factor of 10^-12.";
+      }
+      enum nano {
+        value 6;
+        description
+          "Data scaling factor of 10^-9.";
+      }
+      enum micro {
+        value 7;
+        description
+          "Data scaling factor of 10^-6.";
+      }
+      enum milli {
+        value 8;
+        description
+          "Data scaling factor of 10^-3.";
+      }
+      enum units {
+        value 9;
+        description
+          "Data scaling factor of 10^0.";
+      }
+      enum kilo {
+        value 10;
+        description
+          "Data scaling factor of 10^3.";
+      }
+      enum mega {
+        value 11;
+        description
+          "Data scaling factor of 10^6.";
+      }
+      enum giga {
+        value 12;
+        description
+          "Data scaling factor of 10^9.";
+      }
+      enum tera {
+        value 13;
+        description
+          "Data scaling factor of 10^12.";
+      }
+      enum peta {
+        value 14;
+        description
+          "Data scaling factor of 10^15.";
+      }
+      enum exa {
+        value 15;
+        description
+          "Data scaling factor of 10^18.";
+      }
+      enum zetta {
+        value 16;
+        description
+          "Data scaling factor of 10^21.";
+      }
+      enum yotta {
+        value 17;
+        description
+          "Data scaling factor of 10^24.";
+      }
+    }
+    description
+      "A node using this data type represents a data scaling factor,
+       represented with an International System of Units (SI) prefix.
+       The actual data units are determined by examining a node of
+       this type together with the associated sensor-value-type.
+
+       A node of this type SHOULD be defined together with nodes of
+       type sensor-value-type and type sensor-value-precision.
+       Together, associated nodes of these three types are used to
+       identify the semantics of a node of type sensor-value.";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base -
+                 EntitySensorDataScale";
+  }
+
+  typedef sensor-value-precision {
+    type int8 {
+      range "-8 .. 9";
+    }
+    description
+      "A node using this data type represents a sensor value
+       precision range.
+
+       A node of this type SHOULD be defined together with nodes of
+       type sensor-value-type and type sensor-value-scale.  Together,
+       associated nodes of these three types are used to identify the
+       semantics of a node of type sensor-value.
+
+       If a node of this type contains a value in the range 1 to 9,
+       it represents the number of decimal places in the fractional
+       part of an associated sensor-value fixed-point number.
+
+       If a node of this type contains a value in the range -8 to -1,
+       it represents the number of accurate digits in the associated
+       sensor-value fixed-point number.
+
+       The value zero indicates the associated sensor-value node is
+       not a fixed-point number.
+
+       Server implementers must choose a value for the associated
+       sensor-value-precision node so that the precision and accuracy
+       of the associated sensor-value node is correctly indicated.
+
+       For example, a component representing a temperature sensor
+       that can measure 0 to 100 degrees C in 0.1 degree
+       increments, +/- 0.05 degrees, would have a
+       sensor-value-precision value of '1', a sensor-value-scale
+       value of 'units', and a sensor-value ranging from '0' to
+       '1000'.  The sensor-value would be interpreted as
+       'degrees C * 10'.";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base -
+                 EntitySensorPrecision";
+  }
+
+  typedef sensor-value {
+    type int32 {
+      range "-1000000000 .. 1000000000";
+    }
+    description
+     "A node using this data type represents a sensor value.
+
+      A node of this type SHOULD be defined together with nodes of
+      type sensor-value-type, type sensor-value-scale, and
+      type sensor-value-precision.  Together, associated nodes of
+      those three types are used to identify the semantics of a node
+      of this data type.
+
+      The semantics of a node using this data type are determined by
+      the value of the associated sensor-value-type node.
+
+      If the associated sensor-value-type node is equal to 'voltsAC',
+      'voltsDC', 'amperes', 'watts', 'hertz', 'celsius', or 'cmm',
+      then a node of this type MUST contain a fixed-point number
+      ranging from -999,999,999 to +999,999,999.  The value
+      -1000000000 indicates an underflow error.  The value
+      +1000000000 indicates an overflow error.  The
+      sensor-value-precision indicates how many fractional digits
+      are represented in the associated sensor-value node.
+
+      If the associated sensor-value-type node is equal to
+      'percentRH', then a node of this type MUST contain a number
+      ranging from 0 to 100.
+
+      If the associated sensor-value-type node is equal to 'rpm',
+      then a node of this type MUST contain a number ranging from
+      -999,999,999 to +999,999,999.
+
+      If the associated sensor-value-type node is equal to
+      'truth-value', then a node of this type MUST contain either the
+      value 1 (true) or the value 2 (false).
+
+      If the associated sensor-value-type node is equal to 'other' or
+      'unknown', then a node of this type MUST contain a number
+      ranging from -1000000000 to 1000000000.";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base -
+                 EntitySensorValue";
+  }
+
+  typedef sensor-status {
+    type enumeration {
+      enum ok {
+        value 1;
+        description
+          "Indicates that the server can obtain the sensor value.";
+      }
+      enum unavailable {
+        value 2;
+        description
+          "Indicates that the server presently cannot obtain the
+           sensor value.";
+      }
+      enum nonoperational {
+        value 3;
+        description
+          "Indicates that the server believes the sensor is broken.
+           The sensor could have a hard failure (disconnected wire)
+           or a soft failure such as out-of-range, jittery, or wildly
+           fluctuating readings.";
+      }
+    }
+    description
+      "A node using this data type represents the operational status
+       of a physical sensor.";
+    reference
+      "RFC 3433: Entity Sensor Management Information Base -
+                 EntitySensorStatus";
+  }
+
+  /*
+   * Data nodes
+   */
+
+  container hardware {
+    description
+      "Data nodes representing components.
+
+       If the server supports configuration of hardware components,
+       then this data model is instantiated in the configuration
+       datastores supported by the server.  The leaf-list 'datastore'
+       for the module 'ietf-hardware' in the YANG library provides
+       this information.";
+
+    leaf last-change {
+      type yang:date-and-time;
+      config false;
+      description
+        "The time the '/hardware/component' list changed in the
+         operational state.";
+    }
+
+    list component {
+      key name;
+      description
+        "List of components.
+
+         When the server detects a new hardware component, it
+         initializes a list entry in the operational state.
+
+         If the server does not support configuration of hardware
+         components, list entries in the operational state are
+         initialized with values for all nodes as detected by the
+         implementation.
+
+         Otherwise, this procedure is followed:
+
+           1. If there is an entry in the '/hardware/component' list
+              in the intended configuration with values for the nodes
+              'class', 'parent', and 'parent-rel-pos' that are equal
+              to the detected values, then the list entry in the
+              operational state is initialized with the configured
+              values, including the 'name'.
+
+           2. Otherwise (i.e., there is no matching configuration
+              entry), the list entry in the operational state is
+              initialized with values for all nodes as detected by
+              the implementation.
+
+         If the '/hardware/component' list in the intended
+         configuration is modified, then the system MUST behave as if
+         it re-initializes itself and follow the procedure in (1).";
+      reference
+        "RFC 6933: Entity MIB (Version 4) - entPhysicalEntry";
+
+      leaf name {
+        type string;
+        description
+          "The name assigned to this component.
+
+           This name is not required to be the same as
+           entPhysicalName.";
+      }
+
+      leaf class {
+        type identityref {
+          base ianahw:hardware-class;
+        }
+        mandatory true;
+        description
+          "An indication of the general hardware type of the
+           component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalClass";
+      }
+
+      leaf physical-index {
+        if-feature entity-mib;
+        type int32 {
+          range "1..2147483647";
+        }
+        config false;
+        description
+          "The entPhysicalIndex for the entPhysicalEntry represented
+           by this list entry.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalIndex";
+      }
+
+      leaf description {
+        type string;
+        config false;
+        description
+          "A textual description of the component.  This node should
+           contain a string that identifies the manufacturer's name
+           for the component and should be set to a distinct value
+           for each version or model of the component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalDescr";
+      }
+
+      leaf parent {
+        type leafref {
+          path "../../component/name";
+          require-instance false;
+        }
+        description
+          "The name of the component that physically contains this
+           component.
+
+           If this leaf is not instantiated, it indicates that this
+           component is not contained in any other component.
+
+           In the event that a physical component is contained by
+           more than one physical component (e.g., double-wide
+           modules), this node contains the name of one of these
+           components.  An implementation MUST use the same name
+           every time this node is instantiated.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalContainedIn";
+      }
+
+      leaf parent-rel-pos {
+        type int32 {
+          range "0 .. 2147483647";
+        }
+        description
+          "An indication of the relative position of this child
+           component among all its sibling components.  Sibling
+           components are defined as components that:
+
+             o share the same value of the 'parent' node and
+
+             o share a common base identity for the 'class' node.
+
+           Note that the last rule gives implementations flexibility
+           in how components are numbered.  For example, some
+           implementations might have a single number series for all
+           components derived from 'ianahw:port', while some others
+           might have different number series for different
+           components with identities derived from 'ianahw:port' (for
+           example, one for registered jack 45 (RJ45) and one for
+           small form-factor pluggable (SFP)).";
+
+        reference
+          "RFC 6933: Entity MIB (Version 4) -
+                     entPhysicalParentRelPos";
+      }
+
+      leaf-list contains-child {
+        type leafref {
+          path "../../component/name";
+        }
+        config false;
+        description
+          "The name of the contained component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalChildIndex";
+      }
+
+      leaf hardware-rev {
+        type string;
+        config false;
+        description
+          "The vendor-specific hardware revision string for the
+           component.  The preferred value is the hardware revision
+           identifier actually printed on the component itself (if
+           present).";
+        reference
+          "RFC 6933: Entity MIB (Version 4) -
+                     entPhysicalHardwareRev";
+      }
+
+      leaf firmware-rev {
+        type string;
+        config false;
+        description
+          "The vendor-specific firmware revision string for the
+           component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) -
+                     entPhysicalFirmwareRev";
+      }
+
+      leaf software-rev {
+        type string;
+        config false;
+
+        description
+          "The vendor-specific software revision string for the
+           component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) -
+                     entPhysicalSoftwareRev";
+      }
+
+      leaf serial-num {
+        type string;
+        config false;
+        description
+          "The vendor-specific serial number string for the
+           component.  The preferred value is the serial number
+           string actually printed on the component itself (if
+           present).";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalSerialNum";
+      }
+
+      leaf mfg-name {
+        type string;
+        config false;
+        description
+          "The name of the manufacturer of this physical component.
+           The preferred value is the manufacturer name string
+           actually printed on the component itself (if present).
+
+           Note that comparisons between instances of the
+           'model-name', 'firmware-rev', 'software-rev', and
+           'serial-num' nodes are only meaningful amongst components
+           with the same value of 'mfg-name'.
+
+           If the manufacturer name string associated with the
+           physical component is unknown to the server, then this
+           node is not instantiated.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalMfgName";
+      }
+
+      leaf model-name {
+        type string;
+        config false;
+        description
+          "The vendor-specific model name identifier string
+           associated with this physical component.  The preferred
+           value is the customer-visible part number, which may be
+           printed on the component itself.
+           If the model name string associated with the physical
+           component is unknown to the server, then this node is not
+           instantiated.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalModelName";
+      }
+
+      leaf alias {
+        type string;
+        description
+          "An 'alias' name for the component, as specified by a
+           network manager, that provides a non-volatile 'handle' for
+           the component.
+
+           If no configured value exists, the server MAY set the
+           value of this node to a locally unique value in the
+           operational state.
+
+           A server implementation MAY map this leaf to the
+           entPhysicalAlias MIB object.  Such an implementation needs
+           to use some mechanism to handle the differences in size
+           and characters allowed between this leaf and
+           entPhysicalAlias.  The definition of such a mechanism is
+           outside the scope of this document.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalAlias";
+      }
+
+      leaf asset-id {
+        type string;
+        description
+          "This node is a user-assigned asset tracking identifier for
+           the component.
+
+           A server implementation MAY map this leaf to the
+           entPhysicalAssetID MIB object.  Such an implementation
+           needs to use some mechanism to handle the differences in
+           size and characters allowed between this leaf and
+           entPhysicalAssetID.  The definition of such a mechanism is
+           outside the scope of this document.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalAssetID";
+      }
+
+      leaf is-fru {
+        type boolean;
+        config false;
+
+        description
+          "This node indicates whether or not this component is
+           considered a 'field-replaceable unit' by the vendor.  If
+           this node contains the value 'true', then this component
+           identifies a field-replaceable unit.  For all components
+           that are permanently contained within a field-replaceable
+           unit, the value 'false' should be returned for this
+           node.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalIsFRU";
+      }
+
+      leaf mfg-date {
+        type yang:date-and-time;
+        config false;
+        description
+          "The date of manufacturing of the managed component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalMfgDate";
+      }
+
+      leaf-list uri {
+        type inet:uri;
+        description
+          "This node contains identification information about the
+           component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalUris";
+      }
+
+      leaf uuid {
+        type yang:uuid;
+        config false;
+        description
+          "A Universally Unique Identifier of the component.";
+        reference
+          "RFC 6933: Entity MIB (Version 4) - entPhysicalUUID";
+      }
+
+      container state {
+        if-feature hardware-state;
+        description
+          "State-related nodes";
+        reference
+          "RFC 4268: Entity State MIB";
+
+        leaf state-last-changed {
+          type yang:date-and-time;
+          config false;
+          description
+            "The date and time when the value of any of the
+             admin-state, oper-state, usage-state, alarm-state, or
+             standby-state changed for this component.
+
+             If there has been no change since the last
+             re-initialization of the local system, this node
+             contains the date and time of local system
+             initialization.  If there has been no change since the
+             component was added to the local system, this node
+             contains the date and time of the insertion.";
+          reference
+            "RFC 4268: Entity State MIB - entStateLastChanged";
+        }
+
+        leaf admin-state {
+          type admin-state;
+          description
+            "The administrative state for this component.
+
+             This node refers to a component's administrative
+             permission to service both other components within its
+             containment hierarchy as well other users of its
+             services defined by means outside the scope of this
+             module.
+
+             Some components exhibit only a subset of the remaining
+             administrative state values.  Some components cannot be
+             locked; hence, this node exhibits only the 'unlocked'
+             state.  Other components cannot be shut down gracefully;
+             hence, this node does not exhibit the 'shutting-down'
+             state.";
+          reference
+            "RFC 4268: Entity State MIB - entStateAdmin";
+        }
+
+        leaf oper-state {
+          type oper-state;
+          config false;
+          description
+            "The operational state for this component.
+
+             Note that this node does not follow the administrative
+             state.  An administrative state of 'down' does not
+             predict an operational state of 'disabled'.
+
+             Note that some implementations may not be able to
+             accurately report oper-state while the admin-state node
+             has a value other than 'unlocked'.  In these cases, this
+             node MUST have a value of 'unknown'.";
+          reference
+            "RFC 4268: Entity State MIB - entStateOper";
+        }
+
+        leaf usage-state {
+          type usage-state;
+          config false;
+          description
+            "The usage state for this component.
+
+             This node refers to a component's ability to service
+             more components in a containment hierarchy.
+
+             Some components will exhibit only a subset of the usage
+             state values.  Components that are unable to ever
+             service any components within a containment hierarchy
+             will always have a usage state of 'busy'.  In some
+             cases, a component will be able to support only one
+             other component within its containment hierarchy and
+             will therefore only exhibit values of 'idle' and
+             'busy'.";
+          reference
+            "RFC 4268: Entity State MIB - entStateUsage";
+        }
+
+        leaf alarm-state {
+          type alarm-state;
+          config false;
+          description
+            "The alarm state for this component.  It does not
+             include the alarms raised on child components within its
+             containment hierarchy.";
+          reference
+            "RFC 4268: Entity State MIB - entStateAlarm";
+        }
+
+        leaf standby-state {
+          type standby-state;
+          config false;
+          description
+            "The standby state for this component.
+
+             Some components will exhibit only a subset of the
+             remaining standby state values.  If this component
+             cannot operate in a standby role, the value of this node
+             will always be 'providing-service'.";
+          reference
+            "RFC 4268: Entity State MIB - entStateStandby";
+        }
+      }
+
+      container sensor-data {
+        when 'derived-from-or-self(../class,
+                                   "ianahw:sensor")' {
+          description
+            "Sensor data nodes present for any component of type
+             'sensor'";
+        }
+        if-feature hardware-sensor;
+        config false;
+
+        description
+          "Sensor-related nodes.";
+        reference
+          "RFC 3433: Entity Sensor Management Information Base";
+
+        leaf value {
+          type sensor-value;
+          description
+            "The most recent measurement obtained by the server
+             for this sensor.
+
+             A client that periodically fetches this node should also
+             fetch the nodes 'value-type', 'value-scale', and
+             'value-precision', since they may change when the value
+             is changed.";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorValue";
+        }
+
+        leaf value-type {
+          type sensor-value-type;
+          description
+            "The type of data units associated with the
+             sensor value";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorType";
+        }
+        leaf value-scale {
+          type sensor-value-scale;
+          description
+            "The (power of 10) scaling factor associated
+             with the sensor value";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorScale";
+        }
+
+        leaf value-precision {
+          type sensor-value-precision;
+          description
+            "The number of decimal places of precision
+             associated with the sensor value";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorPrecision";
+        }
+
+        leaf oper-status {
+          type sensor-status;
+          description
+            "The operational status of the sensor.";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorOperStatus";
+        }
+
+        leaf units-display {
+          type string;
+          description
+            "A textual description of the data units that should be
+             used in the display of the sensor value.";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorUnitsDisplay";
+        }
+
+        leaf value-timestamp {
+          type yang:date-and-time;
+          description
+            "The time the status and/or value of this sensor was last
+             obtained by the server.";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorValueTimeStamp";
+        }
+        leaf value-update-rate {
+          type uint32;
+          units "milliseconds";
+          description
+            "An indication of the frequency that the server updates
+             the associated 'value' node, represented in
+             milliseconds.  The value zero indicates:
+
+              - the sensor value is updated on demand (e.g.,
+                when polled by the server for a get-request),
+
+              - the sensor value is updated when the sensor
+                value changes (event-driven), or
+
+              - the server does not know the update rate.";
+          reference
+            "RFC 3433: Entity Sensor Management Information Base -
+                       entPhySensorValueUpdateRate";
+        }
+      }
+    }
+  }
+
+  /*
+   * Notifications
+   */
+
+  notification hardware-state-change {
+    description
+      "A hardware-state-change notification is generated when the
+       value of /hardware/last-change changes in the operational
+       state.";
+    reference
+      "RFC 6933: Entity MIB (Version 4) - entConfigChange";
+  }
+
+  notification hardware-state-oper-enabled {
+    if-feature hardware-state;
+    description
+      "A hardware-state-oper-enabled notification signifies that a
+       component has transitioned into the 'enabled' state.";
+
+    leaf name {
+      type leafref {
+        path "/hardware/component/name";
+      }
+
+      description
+        "The name of the component that has transitioned into the
+         'enabled' state.";
+    }
+    leaf admin-state {
+      type leafref {
+        path "/hardware/component/state/admin-state";
+      }
+      description
+        "The administrative state for the component.";
+    }
+    leaf alarm-state {
+      type leafref {
+        path "/hardware/component/state/alarm-state";
+      }
+      description
+        "The alarm state for the component.";
+    }
+    reference
+      "RFC 4268: Entity State MIB - entStateOperEnabled";
+  }
+
+  notification hardware-state-oper-disabled {
+    if-feature hardware-state;
+    description
+      "A hardware-state-oper-disabled notification signifies that a
+       component has transitioned into the 'disabled' state.";
+
+    leaf name {
+      type leafref {
+        path "/hardware/component/name";
+      }
+      description
+        "The name of the component that has transitioned into the
+         'disabled' state.";
+    }
+    leaf admin-state {
+      type leafref {
+        path "/hardware/component/state/admin-state";
+      }
+      description
+        "The administrative state for the component.";
+    }
+    leaf alarm-state {
+      type leafref {
+        path "/hardware/component/state/alarm-state";
+      }
+
+      description
+        "The alarm state for the component.";
+    }
+    reference
+      "RFC 4268: Entity State MIB - entStateOperDisabled";
+  }
+
+}