module Cisco-IOS-XR-infra-correlator-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-infra-correlator-oper";

    prefix infra-correlator-oper;

    import cisco-semver {
      prefix semver;
    }

    include Cisco-IOS-XR-infra-correlator-oper-sub1 {
      revision-date "2019-04-05";
    }

    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 infra-correlator package operational data.
     
     This module contains definitions
     for the following management objects:
       suppression: Suppression operational data
       correlator: Correlator operational data
     
     Copyright (c) 2013-2019 by Cisco Systems, Inc.
     All rights reserved.";

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

    revision "2017-09-07" {
      description
        "Fixed type translation error.";
    }

    revision "2017-05-01" {
      description
        "Fixing backward compatibility error in module.";
    }

    revision "2015-11-09" {
      description "IOS XR 6.0 revision.";
    }

    semver:module-version "1.0.1";

    container suppression {
      config false;
      description
        "Suppression operational data";
      container rule-summaries {
        description
          "Table that contains the database of suppression
         rule summary";
        list rule-summary {
          key "rule-name";
          description
            "One of the suppression rules";
          leaf rule-name {
            type string {
              length "1..32";
            }
            description
              "Suppression Rule Name";
          }

          leaf rule-name-xr {
            type string;
            description "Suppress Rule Name";
          }

          leaf rule-state {
            type Ac-rule-state;
            description
              "Applied state of the rule It could be not
applied, applied or applied to all";
          }

          leaf suppressed-alarms-count {
            type uint32;
            description
              "Number of suppressed alarms associated with this
rule";
          }
        }  // list rule-summary
      }  // container rule-summaries

      container rule-details {
        description
          "Table that contains the database of suppression
         rule details";
        list rule-detail {
          key "rule-name";
          description
            "Details of one of the suppression rules";
          leaf rule-name {
            type string {
              length "1..32";
            }
            description
              "Suppression Rule Name";
          }

          container rule-summary {
            description
              "Rule summary, name, etc";
            leaf rule-name-xr {
              type string;
              description
                "Suppress Rule Name";
            }

            leaf rule-state {
              type Ac-rule-state;
              description
                "Applied state of the rule It could be not
applied, applied or applied to all";
            }

            leaf suppressed-alarms-count {
              type uint32;
              description
                "Number of suppressed alarms associated with this
rule";
            }
          }  // container rule-summary

          leaf all-alarms {
            type boolean;
            description "Match any alarm";
          }

          leaf alarm-severity {
            type Al-alarm-severity;
            description
              "Severity level to suppress";
          }

          leaf-list apply-source {
            type xr:Node-id;
            description
              "Sources (R/S/M) to which the rule is applied";
          }

          list codes {
            description
              "Message codes defining the rule.";
            leaf category {
              type string;
              description
                "Category of messages to which this alarm belongs";
            }

            leaf group {
              type string;
              description
                "Group of messages to which this alarm belongs";
            }

            leaf code {
              type string;
              description
                "Alarm code which further qualifies the alarm
within a message group";
            }
          }  // list codes
        }  // list rule-detail
      }  // container rule-details
    }  // container suppression

    container correlator {
      config false;
      description
        "Correlator operational data";
      container rules {
        description
          "Table that contains the database of correlation
         rules";
        list rule {
          key "rule-name";
          description
            "One of the correlation rules";
          leaf rule-name {
            type string {
              length "1..32";
            }
            description
              "Correlation Rule Name";
          }

          leaf rule-name-xr {
            type string;
            description
              "Correlation Rule Name";
          }

          leaf timeout {
            type uint32;
            description
              "Time window (in ms) for which root/all messages
are kept in correlater before sending them to
the logger";
          }

          leaf rule-state {
            type Ac-rule-state;
            description
              "Applied state of the rule It could be not
applied, applied or applied to all";
          }

          leaf-list apply-location {
            type xr:Node-id;
            max-elements 32;
            description
              "Locations (R/S/M) to which the rule is  applied";
          }

          leaf-list apply-context {
            type Context;
            max-elements 32;
            description
              "Contexts (Interfaces) to which the rule is
applied";
          }

          list codes {
            max-elements 10;
            description
              "Message codes defining the rule.";
            leaf category {
              type string;
              description
                "Category of messages to which this alarm belongs";
            }

            leaf group {
              type string;
              description
                "Group of messages to which this alarm belongs";
            }

            leaf code {
              type string;
              description
                "Alarm code which further qualifies the alarm
within a message group";
            }
          }  // list codes
        }  // list rule
      }  // container rules

      container buffer-status {
        description
          "Describes buffer utilization and parameters
         configured";
        leaf current-size {
          type uint32;
          description "Current buffer usage";
        }

        leaf configured-size {
          type uint32;
          description
            "Configured buffer size";
        }
      }  // container buffer-status

      container alarms {
        description
          "Correlated alarms Table";
        list alarm {
          key "alarm-id";
          description
            "One of the correlated alarms";
          leaf alarm-id {
            type uint32;
            description "Alarm ID";
          }

          container alarm-info {
            description
              "Correlated alarm information";
            leaf source-id {
              type string;
              description
                "Source Identifier(Location).Indicates the node
in which the alarm was generated";
            }

            leaf timestamp {
              type uint64;
              units "millisecond";
              description
                "Time when the alarm was generated. It is
expressed in number of milliseconds since 00:00
:00 UTC, January 1, 1970";
            }

            leaf category {
              type string;
              description
                "Category of the alarm";
            }

            leaf group {
              type string;
              description
                "Group of messages to which this alarm belongs to";
            }

            leaf code {
              type string;
              description
                "Alarm code which further qualifies the alarm
within a message group";
            }

            leaf severity {
              type Al-alarm-severity;
              description
                "Severity of the alarm";
            }

            leaf state {
              type Al-alarm-bistate;
              description
                "State of the alarm (bistate alarms only)";
            }

            leaf correlation-id {
              type uint32;
              description
                "Correlation Identifier";
            }

            leaf is-admin {
              type boolean;
              description
                "Indicates the event id admin-level";
            }

            leaf additional-text {
              type string;
              description
                "Full text of the Alarm";
            }
          }  // container alarm-info

          leaf rule-name {
            type string;
            description
              "Correlation rule name";
          }

          leaf context {
            type string;
            description
              "Context string  for the alarm";
          }
        }  // list alarm
      }  // container alarms

      container rule-set-summaries {
        description
          "Table that contains the ruleset summary info";
        list rule-set-summary {
          key "rule-set-name";
          description
            "Summary of one of the correlation rulesets";
          leaf rule-set-name {
            type string {
              length "1..32";
            }
            description "Ruleset Name";
          }

          leaf rule-set-name-xr {
            type string;
            description "Ruleset Name";
          }
        }  // list rule-set-summary
      }  // container rule-set-summaries

      container rule-set-details {
        description
          "Table that contains the ruleset detail info";
        list rule-set-detail {
          key "rule-set-name";
          description
            "Detail of one of the correlation rulesets";
          leaf rule-set-name {
            type string {
              length "1..32";
            }
            description "Ruleset Name";
          }

          leaf rule-set-name-xr {
            type string;
            description "Ruleset Name";
          }

          list rules {
            description
              "Rules contained in a ruleset";
            leaf rule-name-xr {
              type string;
              description
                "Correlation Rule Name";
            }

            leaf stateful {
              type boolean;
              description
                "Whether the rule is stateful";
            }

            leaf rule-state {
              type Ac-rule-state;
              description
                "Applied state of the rule It could be not
applied, applied or applied to all";
            }

            leaf buffered-alarms-count {
              type uint32;
              description
                "Number of buffered alarms correlated to this
rule";
            }
          }  // list rules
        }  // list rule-set-detail
      }  // container rule-set-details

      container rule-details {
        description
          "Table that contains the database of correlation
         rule details";
        list rule-detail {
          key "rule-name";
          description
            "Details of one of the correlation rules";
          leaf rule-name {
            type string {
              length "1..32";
            }
            description
              "Correlation Rule Name";
          }

          container rule-summary {
            description
              "Rule summary, name, etc";
            leaf rule-name-xr {
              type string;
              description
                "Correlation Rule Name";
            }

            leaf stateful {
              type boolean;
              description
                "Whether the rule is stateful";
            }

            leaf rule-state {
              type Ac-rule-state;
              description
                "Applied state of the rule It could be not
applied, applied or applied to all";
            }

            leaf buffered-alarms-count {
              type uint32;
              description
                "Number of buffered alarms correlated to this
rule";
            }
          }  // container rule-summary

          leaf timeout {
            type uint32;
            description
              "Time window (in ms) for which root/all messages
are kept in correlater before sending them to
the logger";
          }

          leaf root-cause-timeout {
            type uint32;
            description
              "Timeout before root cause alarm";
          }

          leaf internal {
            type boolean;
            description
              "True if the rule is internal";
          }

          leaf reissue-non-bistate {
            type boolean;
            description
              "Whether to reissue non-bistate alarms";
          }

          leaf reparent {
            type boolean;
            description "Reparent";
          }

          leaf context-correlation {
            type boolean;
            description
              "Whether context correlation is enabled";
          }

          leaf-list apply-location {
            type xr:Node-id;
            description
              "Locations (R/S/M) to which the rule is applied";
          }

          leaf-list apply-context {
            type Context;
            description
              "Contexts (Interfaces) to which the rule is
applied";
          }

          list codes {
            description
              "Message codes defining the rule.";
            leaf category {
              type string;
              description
                "Category of messages to which this alarm belongs";
            }

            leaf group {
              type string;
              description
                "Group of messages to which this alarm belongs";
            }

            leaf code {
              type string;
              description
                "Alarm code which further qualifies the alarm
within a message group";
            }
          }  // list codes
        }  // list rule-detail
      }  // container rule-details

      container rule-summaries {
        description
          "Table that contains the database of correlation
         rule summary";
        list rule-summary {
          key "rule-name";
          description
            "One of the correlation rules";
          leaf rule-name {
            type string {
              length "1..32";
            }
            description
              "Correlation Rule Name";
          }

          leaf rule-name-xr {
            type string;
            description
              "Correlation Rule Name";
          }

          leaf stateful {
            type boolean;
            description
              "Whether the rule is stateful";
          }

          leaf rule-state {
            type Ac-rule-state;
            description
              "Applied state of the rule It could be not
applied, applied or applied to all";
          }

          leaf buffered-alarms-count {
            type uint32;
            description
              "Number of buffered alarms correlated to this
rule";
          }
        }  // list rule-summary
      }  // container rule-summaries
    }  // container correlator
  }  // module Cisco-IOS-XR-infra-correlator-oper