path: root/sdnr/wt/devicemanager-o-ran-sc/o-ran/ru-fh/provider/src/main/yang/ietf-hardware.yang

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";
}

}