module Cisco-IOS-XE-platform-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XE-platform-oper";

    prefix platform-ios-xe-oper;

    import ietf-yang-types {
      prefix yang;
    }
    import cisco-semver {
      prefix cisco-semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service

     Postal: 170 W Tasman Drive
     San Jose, CA 95134

     Tel: +1 1800 553-NETS

     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
     for monitoring of platform components.
     Copyright (c) 2016-2017, 2019 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2019-11-01" {
      description
        "Added status description field";
      reference
        "2.3.0";

    }

    revision "2019-05-01" {
      description
        "- Added component status, temperature
       alarm data and new leaves to component state.
       - Added semantic version";
      reference
        "2.2.0";

    }

    revision "2018-10-29" {
      description
        "Cleaned up spelling errors in descriptions.";
      reference
        "2.1.0";

    }

    revision "2017-10-11" {
      description "Enumeration name fix";
      reference
        "2.0.0";

    }

    revision "2017-02-06" {
      description "Initial revision";
      reference
        "1.0.0";

    }

    cisco-semver:module-version "2.3.0";
    cisco-semver:module-version "2.2.0";
    cisco-semver:module-version "2.1.0";
    cisco-semver:module-version "2.0.0";
    cisco-semver:module-version "1.0.0";

    typedef platform-comp-type {
      type enumeration {
        enum "comp-chassis" {
          value 0;
        }
        enum "comp-backplane" {
          value 1;
        }
        enum "comp-power-supply" {
          value 2;
        }
        enum "comp-fan" {
          value 3;
        }
        enum "comp-sensor" {
          value 4;
        }
        enum "comp-module" {
          value 5;
        }
        enum "comp-linecard" {
          value 6;
        }
        enum "comp-port" {
          value 7;
        }
        enum "comp-cpu" {
          value 8;
        }
        enum "comp-operating-system" {
          value 9;
        }
        enum "comp-optical-channel" {
          value 10;
        }
        enum "comp-container" {
          value 11;
        }
        enum "comp-fru" {
          value 12;
        }
        enum "comp-controller-card" {
          value 13;
        }
        enum "comp-transceiver" {
          value 14;
        }
      }
      description "Component Type";
    }

    typedef platform-comp-status {
      type enumeration {
        enum "status-active" {
          value 0;
        }
        enum "status-inactive" {
          value 1;
        }
        enum "status-disabled" {
          value 2;
        }
      }
      description "Component status";
    }

    typedef temp-alarm-severity {
      type enumeration {
        enum "severity-unknown" {
          value 0;
        }
        enum "severity-minor" {
          value 1;
        }
        enum "severity-major" {
          value 2;
        }
        enum "severity-critical" {
          value 3;
        }
        enum "severity-warning" {
          value 4;
        }
      }
      description
        "Temperature Alarm Severity";
    }

    typedef status-description {
      type enumeration {
        enum "status-desc-ok" {
          value 0;
          description
            "Component in working state";
        }
        enum "status-desc-thermal-failure" {
          value 1;
          description "Thermal failure";
        }
        enum "status-desc-fan-failure" {
          value 2;
          description "Fan failure";
        }
        enum "status-desc-supply-failure" {
          value 3;
          description "Power Supply failure";
        }
        enum "status-desc-no-response" {
          value 4;
          description
            "No response from component";
        }
        enum "status-desc-no-input" {
          value 5;
          description
            "Component has no input";
        }
        enum "status-desc-bad-power" {
          value 6;
          description
            "Component has bad power";
        }
        enum "status-desc-overload" {
          value 7;
          description
            "Component is overloaded";
        }
        enum "status-desc-disabled" {
          value 8;
          description
            "Component is disabled";
        }
        enum "status-desc-vacant" {
          value 9;
          description
            "Component slot is vacant";
        }
        enum "status-desc-standby" {
          value 10;
          description
            "Component is in standby or redundant state";
        }
        enum "status-desc-bad-cookie" {
          value 11;
          description
            "Component failure - bad cookie";
        }
        enum "status-desc-invalid" {
          value 12;
          description
            "Component in invalid state";
        }
      }
      description "Detailed status";
    }

    typedef platform-prop-value-type {
      type enumeration {
        enum "property-string" {
          value 0;
        }
        enum "property-boolean" {
          value 1;
        }
        enum "property-int64" {
          value 2;
        }
        enum "property-uint64" {
          value 3;
        }
        enum "property-decimal64" {
          value 4;
        }
      }
      description "Property value type";
    }

    container components {
      config false;
      description
        "Enclosing container for the components in the system";
      list component {
        key "cname";
        description
          "List of components, keyed by component name";
        leaf cname {
          type string;
          description
            "References component name";
        }

        container state {
          description
            "Operational state data for each component";
          leaf type {
            type platform-comp-type;
            description
              "Type of component as identified by the system";
          }

          leaf id {
            type string;
            description
              "Unique identifier assigned to the component
by the system";
          }

          leaf description {
            type string;
            description
              "System-supplied description of the component";
          }

          leaf mfg-name {
            type string;
            description
              "System-supplied identifier for the manufacturer of the
component.  This data is particularly useful when a
component manufacturer is different than the overall
device vendor";
          }

          leaf version {
            type string;
            description
              "System-defined version string for a hardware, firmware,
or software component";
          }

          leaf serial-no {
            type string;
            description
              "System-assigned serial number of the component";
          }

          leaf part-no {
            type string;
            description
              "System-assigned part number for the component.  This should
be present in particular if the component is also an FRU
(field replaceable unit)";
          }

          container temp {
            description
              "Temperature in degrees Celsius of the component. Values include
the instantaneous, average, minimum, and maximum statistics. If
average/minimum/maximum statistics are not supported, the target is expected
to just supply the instant value";
            leaf temp-instant {
              type decimal64 {
                fraction-digits 2;
              }
              description
                "Instantaneous temperature value of a component";
            }

            leaf temp-avg {
              type decimal64 {
                fraction-digits 2;
              }
              description
                "Arithmetic mean value of the statistic over a
sampling period";
            }

            leaf temp-max {
              type decimal64 {
                fraction-digits 2;
              }
              description
                "High water mark value of the statistic over a
sampling period";
            }

            leaf temp-min {
              type decimal64 {
                fraction-digits 2;
              }
              description
                "Low water mark value of the statistic over a
sampling period";
            }
          }  // container temp

          leaf location {
            type string;
            description
              "Component's Locations";
          }

          leaf empty {
            type boolean;
            description
              "If true, the component is empty";
          }

          leaf mfg-date {
            type yang:date-and-time;
            description
              "Manufacturing date of the component";
          }

          leaf firmware-ver {
            type string;
            description "Firmware version";
          }

          leaf removable {
            type boolean;
            description
              "If true, the component is removable";
          }

          leaf status {
            type platform-comp-status;
            description
              "Operational status of a component";
          }

          container comp-alarm-data {
            description
              "Temperature alarm data of a component";
            leaf alarm-status {
              type boolean;
              description "Alarm status";
            }

            leaf alarm-threshold {
              type uint32;
              description
                "Threshold value above which system generates an alarm";
            }

            leaf severity {
              type temp-alarm-severity;
              description "Alarm Severity";
            }
          }  // container comp-alarm-data

          leaf parent {
            type string;
            description
              "Parent of a component";
          }

          container comp-mem-data {
            description
              "Available and utilized memory of a component";
            leaf mem-available {
              type uint64;
              units "bytes";
              description
                "Available memory for a component";
            }

            leaf mem-utilized {
              type uint64;
              units "bytes";
              description
                "Utilized memory of a component";
            }
          }  // container comp-mem-data

          leaf alloc-pwr {
            type uint32;
            units "watts";
            description
              "Power allocated to a component";
          }

          leaf used-pwr {
            type uint32;
            units "watts";
            description
              "Power drawn by a component";
          }

          leaf status-desc {
            type status-description;
            description
              "Operational status description";
          }
        }  // container state

        container platform-properties {
          description
            "Platform component properties";
          list platform-property {
            key "name";
            description
              "List of platform component properties";
            leaf name {
              type string;
              description "Property name";
            }

            container value {
              description "Property value";
              choice property-value-choice {
                description "Value choice";
                leaf string {
                  type string;
                  description
                    "String property value";
                }
                leaf boolean {
                  type boolean;
                  description
                    "Boolean property value";
                }
                leaf intsixfour {
                  type int64;
                  description
                    "Integer64 property value";
                }
                leaf uintsixfour {
                  type uint64;
                  description
                    "Unsigned integer64 property value";
                }
                leaf decimal {
                  type decimal64 {
                    fraction-digits 2;
                  }
                  description
                    "Decimal64 property value";
                }
              }  // choice property-value-choice
            }  // container value

            leaf configurable {
              type boolean;
              description
                "Indication of whether the property is user-configurable";
            }
          }  // list platform-property
        }  // container platform-properties

        container platform-subcomponents {
          description
            "Platform subcomponents";
          list platform-subcomponent {
            key "name";
            description
              "List of platform subcomponents";
            leaf name {
              type string;
              description
                "Subcomponent name";
            }
          }  // list platform-subcomponent
        }  // container platform-subcomponents
      }  // list component
    }  // container components
  }  // module Cisco-IOS-XE-platform-oper