submodule Cisco-IOS-XR-infra-correlator-oper-sub1 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-infra-correlator-oper {
        prefix
          Cisco-IOS-XR-infra-correlator-oper;
    }

    import Cisco-IOS-XR-types {
      prefix xr;
    }
    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 submodule contains a collection of YANG definitions
     for Cisco IOS-XR infra-correlator package 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";

    typedef Al-alarm-bistate {
      type enumeration {
        enum "not-available" {
          value 0;
          description "not available";
        }
        enum "active" {
          value 1;
          description "active";
        }
        enum "clear" {
          value 2;
          description "clear";
        }
      }
      description "Al alarm bistate";
    }

    typedef Context {
      type string {
        length "0..33";
      }
      description "Context";
    }

    typedef Al-alarm-severity {
      type enumeration {
        enum "unknown" {
          value -1;
          description "unknown";
        }
        enum "emergency" {
          value 0;
          description "emergency";
        }
        enum "alert" {
          value 1;
          description "alert";
        }
        enum "critical" {
          value 2;
          description "critical";
        }
        enum "error" {
          value 3;
          description "error";
        }
        enum "warning" {
          value 4;
          description "warning";
        }
        enum "notice" {
          value 5;
          description "notice";
        }
        enum "informational" {
          value 6;
          description "informational";
        }
        enum "debugging" {
          value 7;
          description "debugging";
        }
      }
      description "Al alarm severity";
    }

    typedef Ac-rule-state {
      type enumeration {
        enum "rule-unapplied" {
          value 0;
          description
            "Rule is in Unapplied state";
        }
        enum "rule-applied" {
          value 1;
          description
            "Rule is Applied to specified RacksSlots,
           Contexts and Sources";
        }
        enum "rule-applied-all" {
          value 2;
          description
            "Rule is Applied to all of router";
        }
      }
      description "Ac rule state";
    }

    grouping AC-RULE-DETAIL-BAG {
      description
        "Correlation Rule detail information";
      container rule-summary {
        description
          "Rule summary, name, etc";
        uses AC-RULE-SUMMARY-BAG;
      }  // 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.";
        uses AC-MSG-CODE;
      }  // list codes
    }  // grouping AC-RULE-DETAIL-BAG

    grouping AC-RULE-SUMMARY-BAG {
      description
        "Correlation Rule summary information";
      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";
      }
    }  // grouping AC-RULE-SUMMARY-BAG

    grouping AC-RULESET-DETAIL-BAG {
      description
        "Correlation Ruleset detail information";
      leaf rule-set-name-xr {
        type string;
        description "Ruleset Name";
      }

      list rules {
        description
          "Rules contained in a ruleset";
        uses AC-RULE-SUMMARY-BAG;
      }  // list rules
    }  // grouping AC-RULESET-DETAIL-BAG

    grouping AC-RULESET-SUMMARY-BAG {
      description
        "Correlation Ruleset summary information";
      leaf rule-set-name-xr {
        type string;
        description "Ruleset Name";
      }
    }  // grouping AC-RULESET-SUMMARY-BAG

    grouping AL-ALDEMS-ALARM-BAG {
      description "Alarm-Logger alarm";
      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";
      }
    }  // grouping AL-ALDEMS-ALARM-BAG

    grouping AC-ALDEMS-ALARM-BAG {
      description "Correlator Alarm";
      container alarm-info {
        description
          "Correlated alarm information";
        uses AL-ALDEMS-ALARM-BAG;
      }  // container alarm-info

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

      leaf context {
        type string;
        description
          "Context string  for the alarm";
      }
    }  // grouping AC-ALDEMS-ALARM-BAG

    grouping AC-BUFFER-INFO-BAG {
      description
        "Correlator buffer usage information";
      leaf current-size {
        type uint32;
        description "Current buffer usage";
      }

      leaf configured-size {
        type uint32;
        description "Configured buffer size";
      }
    }  // grouping AC-BUFFER-INFO-BAG

    grouping AC-RULE-INFO-BAG {
      description
        "Deprecated bag for correlation rule information";
      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.";
        uses AC-MSG-CODE;
      }  // list codes
    }  // grouping AC-RULE-INFO-BAG

    grouping AC-MSG-CODE {
      description "MSG group code pair";
      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";
      }
    }  // grouping AC-MSG-CODE

    grouping AC-SUPPR-RULE-DETAIL-BAG {
      description
        "Suppress Rule detail information";
      container rule-summary {
        description
          "Rule summary, name, etc";
        uses AC-SUPPR-RULE-SUMMARY-BAG;
      }  // 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.";
        uses AC-MSG-CODE;
      }  // list codes
    }  // grouping AC-SUPPR-RULE-DETAIL-BAG

    grouping AC-SUPPR-RULE-SUMMARY-BAG {
      description
        "Suppress Rule summary information";
      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";
      }
    }  // grouping AC-SUPPR-RULE-SUMMARY-BAG
  }  // submodule Cisco-IOS-XR-infra-correlator-oper-sub1