module Cisco-IOS-XR-sysadmin-entity-sensor-mib {

    yang-version 1;

    namespace
      "http://www.cisco.com/ns/yang/Cisco-IOS-XR-sysadmin-entity-sensor-mib";

    prefix CISCO_ENTITY_SENSOR_MIB;

    import ietf-yang-types {
      prefix yang;
    }
    import SNMPv2-TC {
      prefix SNMPv2-TC;
    }
    import Cisco-IOS-XR-sysadmin-entity-mib {
      prefix ENTITY-MIB;
    }
    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG
     definitions for Cisco IOS-XR SysAdmin configuration.
     
     Copyright (c) 2015-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2019-04-15" {
      description
        "Establish semantic version baseline.";
    }

    revision "2017-04-12" {
      description
        "Changed namespace and module name";
    }

    revision "2002-10-16" {
      description "";
    }

    semver:module-version "1.0.0";

    typedef SensorDataType {
      type enumeration {
        enum "other" {
          value 1;
        }
        enum "unknown" {
          value 2;
        }
        enum "voltsAC" {
          value 3;
        }
        enum "voltsDC" {
          value 4;
        }
        enum "amperes" {
          value 5;
        }
        enum "watts" {
          value 6;
        }
        enum "hertz" {
          value 7;
        }
        enum "celsius" {
          value 8;
        }
        enum "percentRH" {
          value 9;
        }
        enum "rpm" {
          value 10;
        }
        enum "cmm" {
          value 11;
        }
        enum "truthvalue" {
          value 12;
        }
        enum "specialEnum" {
          value 13;
        }
      }
    }

    typedef SensorDataScale {
      type enumeration {
        enum "yocto" {
          value 1;
        }
        enum "zepto" {
          value 2;
        }
        enum "atto" {
          value 3;
        }
        enum "femto" {
          value 4;
        }
        enum "pico" {
          value 5;
        }
        enum "nano" {
          value 6;
        }
        enum "micro" {
          value 7;
        }
        enum "milli" {
          value 8;
        }
        enum "units" {
          value 9;
        }
        enum "kilo" {
          value 10;
        }
        enum "mega" {
          value 11;
        }
        enum "giga" {
          value 12;
        }
        enum "tera" {
          value 13;
        }
        enum "exa" {
          value 14;
        }
        enum "peta" {
          value 15;
        }
        enum "zetta" {
          value 16;
        }
        enum "yotta" {
          value 17;
        }
      }
    }

    typedef SensorPrecision {
      type int32 {
        range "-8 .. 9";
      }
    }

    typedef SensorValue {
      type int32 {
        range "-1000000000 .. 1000000000";
      }
    }

    typedef SensorStatus {
      type enumeration {
        enum "ok" {
          value 1;
        }
        enum "unavailable" {
          value 2;
        }
        enum "nonoperational" {
          value 3;
        }
      }
    }

    typedef SensorValueUpdateRate {
      type int32 {
        range "0 .. 999999999";
      }
    }

    typedef SensorThresholdSeverity {
      type enumeration {
        enum "other" {
          value 1;
        }
        enum "minor" {
          value 10;
        }
        enum "major" {
          value 20;
        }
        enum "critical" {
          value 30;
        }
      }
    }

    typedef SensorThresholdRelation {
      type enumeration {
        enum "lessThan" {
          value 1;
        }
        enum "lessOrEqual" {
          value 2;
        }
        enum "greaterThan" {
          value 3;
        }
        enum "greaterOrEqual" {
          value 4;
        }
        enum "equalTo" {
          value 5;
        }
        enum "notEqualTo" {
          value 6;
        }
      }
    }

    typedef entSensorMeasuredEntityType {
      type int32 {
        range "0 .. 2147483647";
      }
    }

    typedef entSensorThresholdIndexType {
      type int32 {
        range "1 .. 99999999";
      }
    }

    container CISCO-ENTITY-SENSOR-MIB {
      container entSensorValueTable {
        config false;
        list entSensorValueEntry {
          key "entPhysicalIndex";
          config false;
          leaf entPhysicalIndex {
            type ENTITY-MIB:PhysicalIndex;
          }

          leaf entSensorType {
            type SensorDataType;
            config false;
          }

          leaf entSensorScale {
            type SensorDataScale;
            config false;
          }

          leaf entSensorPrecision {
            type SensorPrecision;
            config false;
          }

          leaf entSensorValue {
            type SensorValue;
            config false;
          }

          leaf entSensorStatus {
            type SensorStatus;
            config false;
          }

          leaf entSensorValueTimeStamp {
            type yang:timestamp;
            config false;
          }

          leaf entSensorValueUpdateRate {
            type SensorValueUpdateRate;
            config false;
          }

          leaf entSensorMeasuredEntity {
            type entSensorMeasuredEntityType;
            config false;
          }
        }  // list entSensorValueEntry
      }  // container entSensorValueTable

      container entSensorThresholdTable {
        config false;
        list entSensorThresholdEntry {
          key "entPhysicalIndex entSensorThresholdIndex";
          leaf entPhysicalIndex {
            type ENTITY-MIB:PhysicalIndex;
          }

          leaf entSensorThresholdIndex {
            type entSensorThresholdIndexType;
          }

          leaf entSensorThresholdSeverity {
            type SensorThresholdSeverity;
          }

          leaf entSensorThresholdRelation {
            type SensorThresholdRelation;
          }

          leaf entSensorThresholdValue {
            type SensorValue;
          }

          leaf entSensorThresholdEvaluation {
            type SNMPv2-TC:TruthValue;
            config false;
          }

          leaf entSensorThresholdNotificationEnable {
            type SNMPv2-TC:TruthValue;
          }
        }  // list entSensorThresholdEntry
      }  // container entSensorThresholdTable
    }  // container CISCO-ENTITY-SENSOR-MIB
  }  // module Cisco-IOS-XR-sysadmin-entity-sensor-mib