module Cisco-IOS-XR-manageability-perfmgmt-cfg {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-manageability-perfmgmt-cfg";

    prefix manageability-perfmgmt-cfg;

    import ietf-inet-types {
      prefix inet;
    }
    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 module contains a collection of YANG definitions
     for Cisco IOS-XR manageability-perfmgmt package configuration.
     
     This module contains definitions
     for the following management objects:
       perf-mgmt: Performance Management configuration & operations
     
     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.0";

    typedef Pm-threshold-val-range {
      type uint32 {
        range "0..65536";
      }
      description "Pm threshold val range";
    }

    typedef Pm-threshold-val-range-counter32 {
      type uint32 {
        range "0..4294967295";
      }
      description
        "Pm threshold val range counter32";
    }

    typedef Pm-threshold-rearm {
      type enumeration {
        enum "always" {
          value 0;
          description "Rearm Always";
        }
        enum "window" {
          value 1;
          description
            "Rearm after window of sampling periods";
        }
        enum "toggle" {
          value 2;
          description
            "Rearm after the first period when condition is
           not met";
        }
      }
      description "Pm threshold rearm";
    }

    typedef Pm-threshold-op {
      type enumeration {
        enum "eq" {
          value 1;
          description "Equal to";
        }
        enum "ne" {
          value 2;
          description "Not equal to";
        }
        enum "lt" {
          value 3;
          description "Less than";
        }
        enum "le" {
          value 4;
          description
            "Less than or equal to";
        }
        enum "gt" {
          value 5;
          description "Greater than";
        }
        enum "ge" {
          value 6;
          description
            "Greater than or equal to";
        }
        enum "rg" {
          value 7;
          description "Not in Range";
        }
      }
      description "Pm threshold op";
    }

    typedef Pid-range {
      type uint32 {
        range "0..4294967295";
      }
      description "Pid range";
    }

    typedef Pm-threshold-rearm-window {
      type uint32 {
        range "1..100";
      }
      description
        "Pm threshold rearm window";
    }

    grouping REG-EXP-GROUP {
      description
        "Common node of basic-counter-interface-template,
       generic-counter-interface-template,
       data-rate-interface-template";
      leaf reg-exp-group {
        type xr:Cisco-ios-xr-string {
          length "1..32";
        }
        description
          "Enable instance filtering by regular expression";
      }
    }  // grouping REG-EXP-GROUP

    grouping OUTPUT-LS-REQUESTS {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container output-ls-requests {
        presence "enable output-ls-requests";
        description
          "Number of LS Requests sent";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container output-ls-requests
    }  // grouping OUTPUT-LS-REQUESTS

    grouping OSPF-INSTANCE-TABLE {
      description
        "Common node of ospfv2-protocol, ospfv3-protocol";
      container ospf-instances {
        description "Monitor an instance";
        list ospf-instance {
          key "instance-name";
          description
            "Instance being monitored";
          leaf instance-name {
            type xr:Cisco-ios-xr-string;
            description "OSPF Instance Name";
          }

          uses MANAGEABILITY-PERF-ENABLE-MONITOR-CFG-TEMPLATE-NAME;
        }  // list ospf-instance
      }  // container ospf-instances
    }  // grouping OSPF-INSTANCE-TABLE

    grouping INPUT-DB-DS {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container input-db-ds {
        presence "enable input-db-ds";
        description
          "Number of DBD packets received";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container input-db-ds
    }  // grouping INPUT-DB-DS

    grouping NODE-ALL {
      description
        "Common node of cpu-node, memory-node,
       process-node";
      container node-all {
        description "All the the nodes";
        uses TEMPLATE-NAME;
      }  // container node-all
    }  // grouping NODE-ALL

    grouping MANAGEABILITY-PERF-ENABLE-THRESH-CFG-NODE-ALL {
      description
        "Common node of cpu-node, memory-node,
       process-nodeCommon node of cpu-node, memory-node,
       process-node";
      container node-all {
        description "All the the nodes";
        uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-TEMPLATE-NAME;
      }  // container node-all
    }  // grouping MANAGEABILITY-PERF-ENABLE-THRESH-CFG-NODE-ALL

    grouping INPUT-LSA-ACKS-LSA {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container input-lsa-acks-lsa {
        presence "enable input-lsa-acks-lsa";
        description
          "Number of LSA received in LSA Acknowledgements";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container input-lsa-acks-lsa
    }  // grouping INPUT-LSA-ACKS-LSA

    grouping OUTPUT-DB-DS-LSA {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container output-db-ds-lsa {
        presence "enable output-db-ds-lsa";
        description
          "Number of LSA sent in DBD packets";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container output-db-ds-lsa
    }  // grouping OUTPUT-DB-DS-LSA

    grouping TEMPLATE-NAME {
      description
        "Common node of ospfv2-protocol, ospfv3-protocol,
       bgp, node, node-all, ldp-mpls,
       data-rate-interface, generic-counter-interface,
       basic-counter-interface";
      leaf template-name {
        type string;
        description "Template name";
      }
    }  // grouping TEMPLATE-NAME

    grouping MANAGEABILITY-PERF-ENABLE-THRESH-CFG-TEMPLATE-NAME {
      description
        "Common node of ospfv2-protocol, ospfv3-protocol,
       bgp, node, node-all, ldp-mpls,
       data-rate-interface, generic-counter-interface,
       basic-counter-interfaceCommon node of
       ospfv2-protocol, ospfv3-protocol, node, node-all,
       ldp-mpls, data-rate-interface,
       generic-counter-interface,
       basic-counter-interface, bgp";
      leaf template-name {
        type string;
        description "Template name";
      }
    }  // grouping MANAGEABILITY-PERF-ENABLE-THRESH-CFG-TEMPLATE-NAME

    grouping MANAGEABILITY-PERF-ENABLE-MONITOR-CFG-TEMPLATE-NAME {
      description
        "Common node of ospfv2-protocol, ospfv3-protocol,
       bgp, node, node-all, ldp-mpls,
       data-rate-interface, generic-counter-interface,
       basic-counter-interfaceCommon node of
       ospfv2-protocol, ospfv3-protocol, node, node-all,
       ldp-mpls, data-rate-interface,
       generic-counter-interface,
       basic-counter-interface, bgpCommon node of
       ospf-instance, session, pid, node, interface,
       neighbor";
      leaf template-name {
        type string;
        description "Template name";
      }
    }  // grouping MANAGEABILITY-PERF-ENABLE-MONITOR-CFG-TEMPLATE-NAME

    grouping TEMPLATE-TABLE {
      description
        "Common node of ospfv2-protocol, ospfv3-protocol,
       bgp, generic-counter-interface,
       basic-counter-interface, data-rate-interface,
       ldp-mpls, cpu-node, memory-node, process-node";
      container templates {
        description "Template name";
        list template {
          key "template-name";
          description "A template instance";
          leaf reg-exp-group {
            type xr:Cisco-ios-xr-string {
              length "1..32";
            }
            description
              "Enable instance filtering by regular
             expression";
          }

          leaf history-persistent {
            type empty;
            description
              "Enable persistent history statistics";
          }

          leaf vrf-group {
            type xr:Cisco-ios-xr-string {
              length "1..32";
            }
            description
              "VRF group configured in regular expression to
             be applied";
          }

          leaf sample-interval {
            type uint32 {
              range "1..60";
            }
            units "minute";
            description
              "Frequency of each sample in minutes";
          }

          leaf sample-size {
            type uint32 {
              range "1..60";
            }
            description
              "Number of samples to be taken";
          }

          leaf template-name {
            type xr:Cisco-ios-xr-string;
            description "Template Name";
          }
        }  // list template
      }  // container templates
    }  // grouping TEMPLATE-TABLE

    grouping SAMPLE-INTERVAL {
      description
        "Common node of data-rate-interface-template,
       ldp-mpls-template, cpu-node-template,
       memory-node-template, process-node-template";
      leaf sample-interval {
        type uint32 {
          range "1..60";
        }
        units "minute";
        description
          "Frequency of sampling in minutes";
      }
    }  // grouping SAMPLE-INTERVAL

    grouping MANAGEABILITY-PERF-THRESH-CFG-SAMPLE-INTERVAL {
      description
        "Common node of data-rate-interface-template,
       ldp-mpls-template, cpu-node-template,
       memory-node-template, process-node-templateCommon
       node of ospfv2-protocol-template,
       ospfv3-protocol-template, bgp-template,
       basic-counter-interface-template,
       generic-counter-interface-template";
      leaf sample-interval {
        type uint32 {
          range "1..60";
        }
        units "minute";
        description
          "Frequency of sampling in minutes";
      }
    }  // grouping MANAGEABILITY-PERF-THRESH-CFG-SAMPLE-INTERVAL

    grouping INPUT-PACKETS {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container input-packets {
        presence "enable input-packets";
        description
          "Total number of packets received";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container input-packets
    }  // grouping INPUT-PACKETS

    grouping INPUT-LSA-UPDATES-LSA {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container input-lsa-updates-lsa {
        presence
          "enable input-lsa-updates-lsa";
        description
          "Number of LSA received in LSA Updates";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container input-lsa-updates-lsa
    }  // grouping INPUT-LSA-UPDATES-LSA

    grouping VRF-GROUP {
      description
        "Common node of basic-counter-interface-template,
       generic-counter-interface-template,
       data-rate-interface-template";
      leaf vrf-group {
        type xr:Cisco-ios-xr-string {
          length "1..32";
        }
        description
          "Enable instance filtering by VRF name regular
         expression ";
      }
    }  // grouping VRF-GROUP

    grouping OUTPUT-LSA-UPDATES-LSA {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container output-lsa-updates-lsa {
        presence
          "enable output-lsa-updates-lsa";
        description
          "Number of LSA sent in LSA Updates";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container output-lsa-updates-lsa
    }  // grouping OUTPUT-LSA-UPDATES-LSA

    grouping INPUT-LSA-ACKS {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container input-lsa-acks {
        presence "enable input-lsa-acks";
        description
          "Number of LSA Acknowledgements received";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container input-lsa-acks
    }  // grouping INPUT-LSA-ACKS

    grouping INPUT-LSA-UPDATES {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container input-lsa-updates {
        presence "enable input-lsa-updates";
        description
          "Number of LSA Updates received";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container input-lsa-updates
    }  // grouping INPUT-LSA-UPDATES

    grouping OUTPUT-LSA-ACKS-LSA {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container output-lsa-acks-lsa {
        presence
          "enable output-lsa-acks-lsa";
        description
          "Number of LSA sent in LSA Acknowledgements";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container output-lsa-acks-lsa
    }  // grouping OUTPUT-LSA-ACKS-LSA

    grouping INTERFACE-TABLE {
      description
        "Common node of generic-counters, basic-counters,
       data-rates";
      container interfaces {
        description "Monitor an Interface";
        list interface {
          key "interface-name";
          description
            "Interface being Monitored";
          leaf interface-name {
            type xr:Interface-name;
            description "Interface Name";
          }

          uses MANAGEABILITY-PERF-ENABLE-MONITOR-CFG-TEMPLATE-NAME;
        }  // list interface
      }  // container interfaces
    }  // grouping INTERFACE-TABLE

    grouping OUTPUT-PACKETS {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container output-packets {
        presence "enable output-packets";
        description
          "Total number of packets sent";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container output-packets
    }  // grouping OUTPUT-PACKETS

    grouping OUTPUT-LSA-UPDATES {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container output-lsa-updates {
        presence "enable output-lsa-updates";
        description
          "Number of LSA Updates sent";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container output-lsa-updates
    }  // grouping OUTPUT-LSA-UPDATES

    grouping OUTPUT-HELLO-PACKETS {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container output-hello-packets {
        presence
          "enable output-hello-packets";
        description
          "Total number of packets sent";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container output-hello-packets
    }  // grouping OUTPUT-HELLO-PACKETS

    grouping NODE-TABLE {
      description
        "Common node of memory, cpu";
      container nodes {
        description "Node specification";
        list node {
          key "node-id";
          description "Node instance";
          leaf node-id {
            type xr:Node-id;
            description "Node ID";
          }

          uses MANAGEABILITY-PERF-ENABLE-MONITOR-CFG-TEMPLATE-NAME;
        }  // list node
      }  // container nodes
    }  // grouping NODE-TABLE

    grouping MANAGEABILITY-PERF-ENABLE-THRESH-CFG-NODE-TABLE {
      description
        "Common node of memory, cpuCommon node of cpu-node
       , memory-node, process-node";
      container nodes {
        description "Node specification";
        list node {
          key "node-id";
          description "Node instance";
          leaf node-id {
            type xr:Node-id;
            description "Node ID";
          }

          uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-TEMPLATE-NAME;
        }  // list node
      }  // container nodes
    }  // grouping MANAGEABILITY-PERF-ENABLE-THRESH-CFG-NODE-TABLE

    grouping MANAGEABILITY-PERF-ENABLE-STATS-CFG-NODE-TABLE {
      description
        "Common node of memory, cpuCommon node of cpu-node
       , memory-node, process-nodeCommon node of
       cpu-node, memory-node, process-node";
      container nodes {
        description "Node specification";
        list node {
          key "node-id";
          description "Node instance";
          leaf node-id {
            type xr:Node-id;
            description "Node ID";
          }

          uses TEMPLATE-NAME;
        }  // list node
      }  // container nodes
    }  // grouping MANAGEABILITY-PERF-ENABLE-STATS-CFG-NODE-TABLE

    grouping OUTPUT-DB-DS {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container output-db-ds {
        presence "enable output-db-ds";
        description
          "Number of DBD packets sent";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container output-db-ds
    }  // grouping OUTPUT-DB-DS

    grouping INPUT-LS-REQUESTS-LSA {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container input-ls-requests-lsa {
        presence
          "enable input-ls-requests-lsa";
        description
          "Number of LSA received in LS Requests";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container input-ls-requests-lsa
    }  // grouping INPUT-LS-REQUESTS-LSA

    grouping OUTPUT-LS-REQUESTS-LSA {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container output-ls-requests-lsa {
        presence
          "enable output-ls-requests-lsa";
        description
          "Number of LSA sent in LS Requests";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container output-ls-requests-lsa
    }  // grouping OUTPUT-LS-REQUESTS-LSA

    grouping OUTPUT-LSA-ACKS {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container output-lsa-acks {
        presence "enable output-lsa-acks";
        description
          "Number of LSA Acknowledgements sent";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container output-lsa-acks
    }  // grouping OUTPUT-LSA-ACKS

    grouping INPUT-DB-DS-LSA {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container input-db-ds-lsa {
        presence "enable input-db-ds-lsa";
        description
          "Number of LSA received in DBD packets";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container input-db-ds-lsa
    }  // grouping INPUT-DB-DS-LSA

    grouping INPUT-LS-REQUESTS {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container input-ls-requests {
        presence "enable input-ls-requests";
        description
          "Number of LS Requests received";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container input-ls-requests
    }  // grouping INPUT-LS-REQUESTS

    grouping INPUT-HELLO-PACKETS {
      description
        "Common node of ospfv2-protocol-template,
       ospfv3-protocol-template";
      container input-hello-packets {
        presence
          "enable input-hello-packets";
        description
          "Number of Hello packets received";
        leaf operator {
          type Pm-threshold-op;
          description "Operator";
        }

        leaf value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold value (or start range value for
           operator RG)";
        }

        leaf end-range-value {
          type Pm-threshold-val-range-counter32;
          description
            "Threshold end range value (for operator RG, set
           to 0 otherwise)";
        }

        leaf percent {
          type boolean;
          description
            "Set to TRUE if Specified threshold values are
           in percent";
        }

        leaf rearm-type {
          type Pm-threshold-rearm;
          description
            "Configure the Rearm type";
        }

        leaf rearm-window {
          type Pm-threshold-rearm-window;
          description
            "Configure the rearm window size (for rearm type
           Window)";
        }
      }  // container input-hello-packets
    }  // grouping INPUT-HELLO-PACKETS

    container perf-mgmt {
      description
        "Performance Management configuration & operations";
      container resources {
        description
          "Resources configuration";
        container tftp-resources {
          presence
            "Indicates a tftp-resources node is configured.";
          description
            "Configure the TFTP server IP address and
           directory name";
          leaf server-address {
            type inet:ipv4-address-no-zone;
            mandatory true;
            description
              "IP address of the TFTP server";
          }

          leaf directory {
            type string;
            mandatory true;
            description
              "Directory name on TFTP server";
          }

          leaf vrf-name {
            type xr:Cisco-ios-xr-string {
              length "1..32";
            }
            description "VRF name";
          }
        }  // container tftp-resources

        container dump-local {
          description
            "Configure local dump parameters";
          leaf enable {
            type empty;
            description
              "Enable data dump onto local filesystem";
          }
        }  // container dump-local

        container memory-resources {
          description
            "Configure the memory usage limits of
           performance management";
          leaf max-limit {
            type uint32;
            units "kilobyte";
            description
              "Maximum limit for memory usage (Kbytes) for
             data buffers";
          }

          leaf min-reserved {
            type uint32;
            units "kilobyte";
            description
              "Specify a minimum free memory (Kbytes) to be
             ensured before allowing a collection request";
          }
        }  // container memory-resources
      }  // container resources

      container statistics {
        description
          "Templates for collection of statistics";
        container generic-counter-interface {
          description
            "Interface Generic GenericCounter collection
           templates";
          uses TEMPLATE-TABLE;
        }  // container generic-counter-interface

        container process-node {
          description
            "Node Process collection templates";
          uses TEMPLATE-TABLE;
        }  // container process-node

        container basic-counter-interface {
          description
            "Interface BasicCounter collection templates";
          uses TEMPLATE-TABLE;
        }  // container basic-counter-interface

        container ospfv3-protocol {
          description
            "OSPF v3 Protocol collection templates";
          uses TEMPLATE-TABLE;
        }  // container ospfv3-protocol

        container cpu-node {
          description
            "Node CPU collection templates";
          uses TEMPLATE-TABLE;
        }  // container cpu-node

        container data-rate-interface {
          description
            "Interface DataRate collection templates";
          uses TEMPLATE-TABLE;
        }  // container data-rate-interface

        container memory-node {
          description
            "Node Memory collection templates";
          uses TEMPLATE-TABLE;
        }  // container memory-node

        container ldp-mpls {
          description
            "MPLS LDP collection templates";
          uses TEMPLATE-TABLE;
        }  // container ldp-mpls

        container bgp {
          description
            "BGP collection templates";
          uses TEMPLATE-TABLE;
        }  // container bgp

        container ospfv2-protocol {
          description
            "OSPF v2 Protocol collection templates";
          uses TEMPLATE-TABLE;
        }  // container ospfv2-protocol
      }  // container statistics

      container enable {
        description
          "Start data collection and/or threshold
         monitoring";
        container threshold {
          description
            "Start threshold monitoring using a defined
           template";
          container ospfv3-protocol {
            description
              "Threshold monitoring for OSPF v3 Protocol";
            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-TEMPLATE-NAME;
          }  // container ospfv3-protocol

          container bgp {
            description
              "Threshold monitoring for BGP";
            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-TEMPLATE-NAME;
          }  // container bgp

          container data-rate-interface {
            description
              "Threshold monitoring for Interface  data-rates";
            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-TEMPLATE-NAME;
          }  // container data-rate-interface

          container ospfv2-protocol {
            description
              "Threshold monitoring for OSPF v2 Protocol";
            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-TEMPLATE-NAME;
          }  // container ospfv2-protocol

          container memory-node {
            description
              "Threshold monitoring for memory";
            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-NODE-TABLE;

            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-NODE-ALL;
          }  // container memory-node

          container generic-counter-interface {
            description
              "Threshold monitoring for Interface
             generic-counters";
            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-TEMPLATE-NAME;
          }  // container generic-counter-interface

          container cpu-node {
            description
              "Threshold monitoring for CPU";
            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-NODE-TABLE;

            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-NODE-ALL;
          }  // container cpu-node

          container ldp-mpls {
            description
              "Threshold monitoring for LDP";
            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-TEMPLATE-NAME;
          }  // container ldp-mpls

          container process-node {
            description
              "Threshold monitoring for process";
            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-NODE-TABLE;

            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-NODE-ALL;
          }  // container process-node

          container basic-counter-interface {
            description
              "Threshold monitoring for Interface
             basic-counters";
            uses MANAGEABILITY-PERF-ENABLE-THRESH-CFG-TEMPLATE-NAME;
          }  // container basic-counter-interface
        }  // container threshold

        container statistics {
          description
            "Start periodic collection using a defined a
           template";
          container generic-counter-interface {
            description
              "Statistics collection for generic-counters";
            uses TEMPLATE-NAME;
          }  // container generic-counter-interface

          container bgp {
            description
              "Data collection for BGP";
            uses TEMPLATE-NAME;
          }  // container bgp

          container ospfv2-protocol {
            description
              "Data collection for OSPF v2 Protocol";
            uses TEMPLATE-NAME;
          }  // container ospfv2-protocol

          container ospfv3-protocol {
            description
              "Data collection for OSPF v3 Protocol";
            uses TEMPLATE-NAME;
          }  // container ospfv3-protocol

          container cpu-node {
            description "Collection for CPU";
            uses NODE-ALL;

            uses MANAGEABILITY-PERF-ENABLE-STATS-CFG-NODE-TABLE;
          }  // container cpu-node

          container basic-counter-interface {
            description
              "Statistics collection for basic-counters";
            uses TEMPLATE-NAME;
          }  // container basic-counter-interface

          container process-node {
            description
              "Collection for process";
            uses NODE-ALL;

            uses MANAGEABILITY-PERF-ENABLE-STATS-CFG-NODE-TABLE;
          }  // container process-node

          container data-rate-interface {
            description
              "Statistics collection for generic-counters";
            uses TEMPLATE-NAME;
          }  // container data-rate-interface

          container memory-node {
            description
              "Collection for memory";
            uses NODE-ALL;

            uses MANAGEABILITY-PERF-ENABLE-STATS-CFG-NODE-TABLE;
          }  // container memory-node

          container ldp-mpls {
            description
              "Collection for labels distribution protocol";
            uses TEMPLATE-NAME;
          }  // container ldp-mpls
        }  // container statistics

        container monitor-enable {
          description
            "Start data collection for a monitored instance";
          container ldp-mpls {
            description "Monitoring for LDP";
            container sessions {
              description
                "LDP session specification";
              list session {
                key "session";
                description
                  "IP address of the LDP Session";
                leaf session {
                  type inet:ipv4-address-no-zone;
                  description
                    "IP address of the LDP Session";
                }

                uses MANAGEABILITY-PERF-ENABLE-MONITOR-CFG-TEMPLATE-NAME;
              }  // list session
            }  // container sessions
          }  // container ldp-mpls

          container ospfv3-protocol {
            description
              "Monitor OSPF v3 Protocol";
            uses OSPF-INSTANCE-TABLE;
          }  // container ospfv3-protocol

          container generic-counters {
            description
              "Monitoring for generic-counters";
            uses INTERFACE-TABLE;
          }  // container generic-counters

          container process {
            description
              "Collection for a single process";
            container process-nodes {
              description
                "Node specification";
              list process-node {
                key "node-id";
                description "Node instance";
                container pids {
                  description
                    "Process ID specification";
                  list pid {
                    key "pid";
                    description
                      "Specify an existing template for data
                     collection";
                    leaf pid {
                      type Pid-range;
                      description
                        "Specify Process ID";
                    }

                    uses MANAGEABILITY-PERF-ENABLE-MONITOR-CFG-TEMPLATE-NAME;
                  }  // list pid
                }  // container pids

                leaf node-id {
                  type xr:Node-id;
                  description "Node ID";
                }
              }  // list process-node
            }  // container process-nodes
          }  // container process

          container basic-counters {
            description
              "Monitoring for basic-counters";
            uses INTERFACE-TABLE;
          }  // container basic-counters

          container memory {
            description
              "Collection for memory";
            uses NODE-TABLE;
          }  // container memory

          container ospfv2-protocol {
            description
              "Monitor OSPF v2 Protocol";
            uses OSPF-INSTANCE-TABLE;
          }  // container ospfv2-protocol

          container cpu {
            description "Collection for CPU";
            uses NODE-TABLE;
          }  // container cpu

          container bgp {
            description
              "Monitor BGP protocol";
            container neighbors {
              description
                "Monitor BGP protocol for a BGP peer";
              list neighbor {
                key "peer-address";
                description
                  "Neighbor being monitored";
                leaf peer-address {
                  type inet:ipv4-address-no-zone;
                  description
                    "IP address of the Neighbor";
                }

                uses MANAGEABILITY-PERF-ENABLE-MONITOR-CFG-TEMPLATE-NAME;
              }  // list neighbor
            }  // container neighbors
          }  // container bgp

          container data-rates {
            description
              "Monitoring for data-rates";
            uses INTERFACE-TABLE;
          }  // container data-rates
        }  // container monitor-enable
      }  // container enable

      container reg-exp-groups {
        description
          "Configure regular expression group";
        list reg-exp-group {
          key "reg-exp-group-name";
          description
            "Specify regular expression group name";
          container reg-exps {
            description
              "Configure regular expression";
            list reg-exp {
              key "reg-exp-index";
              description
                "Specify regular expression index number";
              leaf reg-exp-index {
                type uint32 {
                  range "1..100";
                }
                description
                  "Regular expression index number";
              }

              leaf reg-exp-string {
                type string {
                  length "1..128";
                }
                mandatory true;
                description
                  "Regular expression string to match";
              }
            }  // list reg-exp
          }  // container reg-exps

          leaf reg-exp-group-name {
            type xr:Cisco-ios-xr-string {
              length "1..32";
            }
            description
              "Regular expression group name";
          }
        }  // list reg-exp-group
      }  // container reg-exp-groups

      container threshold {
        description
          "Container for threshold templates";
        container generic-counter-interface {
          description
            "Interface Generic Counter threshold
           configuration";
          container generic-counter-interface-templates {
            description
              "Interface Generic Counter threshold templates";
            list generic-counter-interface-template {
              key "template-name";
              description
                "Interface Generic Counter threshold template
               instance";
              container in-octets {
                presence "enable in-octets";
                description
                  "Number of inbound octets/bytes";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container in-octets

              container in-ucast-pkts {
                presence
                  "enable in-ucast-pkts";
                description
                  "Number of inbound unicast packets";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container in-ucast-pkts

              container out-ucast-pkts {
                presence
                  "enable out-ucast-pkts";
                description
                  "Number of outbound unicast packets";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container out-ucast-pkts

              container out-broadcast-pkts {
                presence
                  "enable out-broadcast-pkts";
                description
                  "Number of outbound broadcast packets";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container out-broadcast-pkts

              container out-multicast-pkts {
                presence
                  "enable out-multicast-pkts";
                description
                  "Number of outbound multicast packets";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container out-multicast-pkts

              container input-overrun {
                presence
                  "enable input-overrun";
                description
                  "Number of inbound packets with overrun
                 errors";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-overrun

              container out-octets {
                presence "enable out-octets";
                description
                  "Number of outbound octets/bytes";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container out-octets

              container output-underrun {
                presence
                  "enable output-underrun";
                description
                  "Number of outbound packets with underrun
                 errors";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-underrun

              container input-total-errors {
                presence
                  "enable input-total-errors";
                description
                  "Number of inbound incorrect packets
                 discarded";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-total-errors

              container output-total-drops {
                presence
                  "enable output-total-drops";
                description
                  "Number of outbound correct packets discarded";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-total-drops

              container input-crc {
                presence "enable input-crc";
                description
                  "Number of inbound packets discarded with
                 incorrect CRC";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-crc

              container in-broadcast-pkts {
                presence
                  "enable in-broadcast-pkts";
                description
                  "Number of inbound broadcast packets";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container in-broadcast-pkts

              container in-multicast-pkts {
                presence
                  "enable in-multicast-pkts";
                description
                  "Number of inbound multicast packets";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container in-multicast-pkts

              container out-packets {
                presence
                  "enable out-packets";
                description
                  "Number of outbound packets";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container out-packets

              container output-total-errors {
                presence
                  "enable output-total-errors";
                description
                  "Number of outbound incorrect packets
                 discarded";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-total-errors

              container in-packets {
                presence "enable in-packets";
                description
                  "Number of inbound packets";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container in-packets

              container input-unknown-proto {
                presence
                  "enable input-unknown-proto";
                description
                  "Number of inbound packets discarded with
                 unknown protocol";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-unknown-proto

              container input-queue-drops {
                presence
                  "enable input-queue-drops";
                description
                  "Number of input queue drops";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-queue-drops

              container input-total-drops {
                presence
                  "enable input-total-drops";
                description
                  "Number of inbound correct packets discarded";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-total-drops

              container input-frame {
                presence
                  "enable input-frame";
                description
                  "Number of inbound packets with framing
                 errors";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-frame

              leaf template-name {
                type xr:Cisco-ios-xr-string;
                description "Template Name";
              }

              uses MANAGEABILITY-PERF-THRESH-CFG-SAMPLE-INTERVAL;

              uses REG-EXP-GROUP;

              uses VRF-GROUP;
            }  // list generic-counter-interface-template
          }  // container generic-counter-interface-templates
        }  // container generic-counter-interface

        container ldp-mpls {
          description
            "MPLS LDP threshold configuration";
          container ldp-mpls-templates {
            description
              "MPLS LDP threshold templates";
            list ldp-mpls-template {
              key "template-name";
              description
                "MPLS LDP threshold template instance";
              container address-withdraw-msgs-rcvd {
                presence
                  "enable address-withdraw-msgs-rcvd";
                description
                  "Number of Address Withdraw messages received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container address-withdraw-msgs-rcvd

              container label-withdraw-msgs-rcvd {
                presence
                  "enable label-withdraw-msgs-rcvd";
                description
                  "Number of Label Withdraw messages received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container label-withdraw-msgs-rcvd

              container address-withdraw-msgs-sent {
                presence
                  "enable address-withdraw-msgs-sent";
                description
                  "Number of Address Withdraw messages sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container address-withdraw-msgs-sent

              container label-withdraw-msgs-sent {
                presence
                  "enable label-withdraw-msgs-sent";
                description
                  "Number of Label Withdraw messages sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container label-withdraw-msgs-sent

              container notification-msgs-rcvd {
                presence
                  "enable notification-msgs-rcvd";
                description
                  "Number of Notification messages received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container notification-msgs-rcvd

              container total-msgs-rcvd {
                presence
                  "enable total-msgs-rcvd";
                description
                  "Total number of messages received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container total-msgs-rcvd

              container notification-msgs-sent {
                presence
                  "enable notification-msgs-sent";
                description
                  "Number of Notification messages sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container notification-msgs-sent

              container total-msgs-sent {
                presence
                  "enable total-msgs-sent";
                description
                  "Total number of messages sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container total-msgs-sent

              container label-release-msgs-rcvd {
                presence
                  "enable label-release-msgs-rcvd";
                description
                  "Number of LAbel Release messages received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container label-release-msgs-rcvd

              container init-msgs-rcvd {
                presence
                  "enable init-msgs-rcvd";
                description
                  "Number of Init messages received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container init-msgs-rcvd

              container label-release-msgs-sent {
                presence
                  "enable label-release-msgs-sent";
                description
                  "Number of Label Release messages sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container label-release-msgs-sent

              container init-msgs-sent {
                presence
                  "enable init-msgs-sent";
                description
                  "Number of Init messages sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container init-msgs-sent

              container label-mapping-msgs-rcvd {
                presence
                  "enable label-mapping-msgs-rcvd";
                description
                  "Number of Label Mapping messages received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container label-mapping-msgs-rcvd

              container keepalive-msgs-rcvd {
                presence
                  "enable keepalive-msgs-rcvd";
                description
                  "Number of Keepalive messages received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container keepalive-msgs-rcvd

              container label-mapping-msgs-sent {
                presence
                  "enable label-mapping-msgs-sent";
                description
                  "Number of Label Mapping messages sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container label-mapping-msgs-sent

              container keepalive-msgs-sent {
                presence
                  "enable keepalive-msgs-sent";
                description
                  "Number of Keepalive messages sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container keepalive-msgs-sent

              container address-msgs-rcvd {
                presence
                  "enable address-msgs-rcvd";
                description
                  "Number of Address messages received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container address-msgs-rcvd

              container address-msgs-sent {
                presence
                  "enable address-msgs-sent";
                description
                  "Number of Address messages sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container address-msgs-sent

              leaf template-name {
                type xr:Cisco-ios-xr-string;
                description "Template Name";
              }

              uses SAMPLE-INTERVAL;
            }  // list ldp-mpls-template
          }  // container ldp-mpls-templates
        }  // container ldp-mpls

        container basic-counter-interface {
          description
            "Interface Basic Counter threshold configuration";
          container basic-counter-interface-templates {
            description
              "Interface Basic Counter threshold templates";
            list basic-counter-interface-template {
              key "template-name";
              description
                "Interface Basic Counter threshold template
               instance";
              container in-octets {
                presence "enable in-octets";
                description
                  "Number of inbound octets/bytes";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container in-octets

              container out-octets {
                presence "enable out-octets";
                description
                  "Number of outbound octets/bytes";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container out-octets

              container output-queue-drops {
                presence
                  "enable output-queue-drops";
                description
                  "Number of outbound queue drops";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-queue-drops

              container input-total-errors {
                presence
                  "enable input-total-errors";
                description
                  "Number of inbound incorrect packets
                 discarded";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-total-errors

              container output-total-drops {
                presence
                  "enable output-total-drops";
                description
                  "Number of outbound correct packets discarded";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-total-drops

              container out-packets {
                presence
                  "enable out-packets";
                description
                  "Number of outbound packets";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container out-packets

              container output-total-errors {
                presence
                  "enable output-total-errors";
                description
                  "Number of outbound incorrect packets
                 discarded";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-total-errors

              container in-packets {
                presence "enable in-packets";
                description
                  "Number of inbound packets";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container in-packets

              container input-queue-drops {
                presence
                  "enable input-queue-drops";
                description
                  "Number of input queue drops";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-queue-drops

              container input-total-drops {
                presence
                  "enable input-total-drops";
                description
                  "Number of inbound correct packets discarded";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-total-drops

              leaf template-name {
                type xr:Cisco-ios-xr-string;
                description "Template Name";
              }

              uses MANAGEABILITY-PERF-THRESH-CFG-SAMPLE-INTERVAL;

              uses REG-EXP-GROUP;

              uses VRF-GROUP;
            }  // list basic-counter-interface-template
          }  // container basic-counter-interface-templates
        }  // container basic-counter-interface

        container bgp {
          description
            "BGP threshold configuration";
          container bgp-templates {
            description
              "BGP threshold templates";
            list bgp-template {
              key "template-name";
              description
                "BGP threshold template instance";
              container output-update-messages {
                presence
                  "enable output-update-messages";
                description
                  "Number of update messages sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-update-messages

              container errors-received {
                presence
                  "enable errors-received";
                description
                  "Number of error notifications received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container errors-received

              container conn-established {
                presence
                  "enable conn-established";
                description
                  "Number of times the connection was
                 established";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container conn-established

              container output-messages {
                presence
                  "enable output-messages";
                description
                  "Number of messages sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-messages

              container conn-dropped {
                presence
                  "enable conn-dropped";
                description
                  "Number of times the connection was dropped";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container conn-dropped

              container input-update-messages {
                presence
                  "enable input-update-messages";
                description
                  "Number of update messages received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-update-messages

              container errors-sent {
                presence
                  "enable errors-sent";
                description
                  "Number of error notifications sent";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container errors-sent

              container input-messages {
                presence
                  "enable input-messages";
                description
                  "Number of messages received";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-messages

              leaf template-name {
                type xr:Cisco-ios-xr-string;
                description "Template Name";
              }

              uses MANAGEABILITY-PERF-THRESH-CFG-SAMPLE-INTERVAL;
            }  // list bgp-template
          }  // container bgp-templates
        }  // container bgp

        container ospfv2-protocol {
          description
            "OSPF v2 Protocol threshold configuration";
          container ospfv2-protocol-templates {
            description
              "OSPF v2 Protocol threshold templates";
            list ospfv2-protocol-template {
              key "template-name";
              description
                "OSPF v2 Protocol threshold template instance";
              container checksum-errors {
                presence
                  "enable checksum-errors";
                description
                  "Number of packets received with checksum
                 errors";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container checksum-errors

              leaf template-name {
                type xr:Cisco-ios-xr-string;
                description "Template Name";
              }

              uses INPUT-LSA-ACKS-LSA;

              uses OUTPUT-DB-DS-LSA;

              uses INPUT-DB-DS-LSA;

              uses INPUT-LSA-UPDATES;

              uses OUTPUT-DB-DS;

              uses OUTPUT-LSA-UPDATES-LSA;

              uses INPUT-DB-DS;

              uses INPUT-LSA-UPDATES-LSA;

              uses MANAGEABILITY-PERF-THRESH-CFG-SAMPLE-INTERVAL;

              uses OUTPUT-PACKETS;

              uses INPUT-PACKETS;

              uses OUTPUT-HELLO-PACKETS;

              uses INPUT-HELLO-PACKETS;

              uses OUTPUT-LS-REQUESTS;

              uses OUTPUT-LSA-ACKS-LSA;

              uses OUTPUT-LSA-ACKS;

              uses INPUT-LSA-ACKS;

              uses OUTPUT-LSA-UPDATES;

              uses OUTPUT-LS-REQUESTS-LSA;

              uses INPUT-LS-REQUESTS-LSA;

              uses INPUT-LS-REQUESTS;
            }  // list ospfv2-protocol-template
          }  // container ospfv2-protocol-templates
        }  // container ospfv2-protocol

        container cpu-node {
          description
            "Node CPU threshold configuration";
          container cpu-node-templates {
            description
              "Node CPU threshold configuration templates";
            list cpu-node-template {
              key "template-name";
              description
                "Node CPU threshold configuration template
               instances";
              container average-cpu-used {
                presence
                  "enable average-cpu-used";
                description
                  "Average %CPU utilization";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32 {
                    range "0..100";
                  }
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32 {
                    range "0..100";
                  }
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container average-cpu-used

              container no-processes {
                presence
                  "enable no-processes";
                description
                  "Number of processes";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container no-processes

              leaf template-name {
                type xr:Cisco-ios-xr-string;
                description "Template Name";
              }

              uses SAMPLE-INTERVAL;
            }  // list cpu-node-template
          }  // container cpu-node-templates
        }  // container cpu-node

        container data-rate-interface {
          description
            "Interface Data Rates threshold configuration";
          container data-rate-interface-templates {
            description
              "Interface Data Rates threshold templates";
            list data-rate-interface-template {
              key "template-name";
              description
                "Interface Data Rates threshold template
               instance";
              container input-data-rate {
                presence
                  "enable input-data-rate";
                description
                  "Input data rate in kbps";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-data-rate

              container bandwidth {
                presence "enable bandwidth";
                description
                  "Bandwidth in kbps";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container bandwidth

              container output-packet-rate {
                presence
                  "enable output-packet-rate";
                description
                  "Number of Output packets per second";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-packet-rate

              container input-peak-pkts {
                presence
                  "enable input-peak-pkts";
                description
                  "Maximum number of input packets per second";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-peak-pkts

              container output-peak-rate {
                presence
                  "enable output-peak-rate";
                description
                  "Peak output data rate in kbps";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-peak-rate

              container output-data-rate {
                presence
                  "enable output-data-rate";
                description
                  "Output data rate in kbps";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-data-rate

              container input-packet-rate {
                presence
                  "enable input-packet-rate";
                description
                  "Number of input packets per second";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-packet-rate

              container output-peak-pkts {
                presence
                  "enable output-peak-pkts";
                description
                  "Maximum number of output packets per second";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container output-peak-pkts

              container input-peak-rate {
                presence
                  "enable input-peak-rate";
                description
                  "Peak input data rate in kbps";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type Pm-threshold-val-range-counter32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container input-peak-rate

              leaf template-name {
                type xr:Cisco-ios-xr-string;
                description "Template Name";
              }

              uses SAMPLE-INTERVAL;

              uses REG-EXP-GROUP;

              uses VRF-GROUP;
            }  // list data-rate-interface-template
          }  // container data-rate-interface-templates
        }  // container data-rate-interface

        container process-node {
          description
            "Node Process threshold configuration";
          container process-node-templates {
            description
              "Node Memory threshold templates";
            list process-node-template {
              key "template-name";
              description
                "Node Memory threshold template instance";
              container average-cpu-used {
                presence
                  "enable average-cpu-used";
                description
                  "Average %CPU utilization";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32 {
                    range "0..100";
                  }
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32 {
                    range "0..100";
                  }
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container average-cpu-used

              container peak-memory {
                presence
                  "enable peak-memory";
                description
                  "Max memory (KBytes) used since startup time";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container peak-memory

              container no-threads {
                presence "enable no-threads";
                description
                  "Number of threads";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32 {
                    range "0..32767";
                  }
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32 {
                    range "0..32767";
                  }
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container no-threads

              leaf template-name {
                type xr:Cisco-ios-xr-string;
                description "Template Name";
              }

              uses SAMPLE-INTERVAL;
            }  // list process-node-template
          }  // container process-node-templates
        }  // container process-node

        container memory-node {
          description
            "Node Memory threshold configuration";
          container memory-node-templates {
            description
              "Node Memory threshold configuration templates";
            list memory-node-template {
              key "template-name";
              description
                "Node Memory threshold configuration template
               instance";
              container peak-memory {
                presence
                  "enable peak-memory";
                description
                  "Maximum memory (KBytes) used";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32 {
                    range "0..4194304";
                  }
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32 {
                    range "0..4194304";
                  }
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container peak-memory

              container curr-memory {
                presence
                  "enable curr-memory";
                description
                  "Current memory (Bytes) in use";
                leaf operator {
                  type Pm-threshold-op;
                  description "Operator";
                }

                leaf value {
                  type uint32;
                  description
                    "Threshold value (or start range value for
                   operator RG)";
                }

                leaf end-range-value {
                  type uint32;
                  description
                    "Threshold end range value (for operator RG,
                   set to 0 otherwise)";
                }

                leaf percent {
                  type boolean;
                  description
                    "Set to TRUE if Specified threshold values
                   are in percent";
                }

                leaf rearm-type {
                  type Pm-threshold-rearm;
                  description
                    "Configure the Rearm type";
                }

                leaf rearm-window {
                  type Pm-threshold-rearm-window;
                  description
                    "Configure the rearm window size (for rearm
                   type Window)";
                }
              }  // container curr-memory

              leaf template-name {
                type xr:Cisco-ios-xr-string;
                description "Template Name";
              }

              uses SAMPLE-INTERVAL;
            }  // list memory-node-template
          }  // container memory-node-templates
        }  // container memory-node

        container ospfv3-protocol {
          description
            "OSPF v2 Protocol threshold configuration";
          container ospfv3-protocol-templates {
            description
              "OSPF v2 Protocol threshold templates";
            list ospfv3-protocol-template {
              key "template-name";
              description
                "OSPF v2 Protocol threshold template instance";
              leaf template-name {
                type xr:Cisco-ios-xr-string;
                description "Template Name";
              }

              uses INPUT-LSA-ACKS-LSA;

              uses OUTPUT-DB-DS-LSA;

              uses INPUT-DB-DS-LSA;

              uses INPUT-LSA-UPDATES;

              uses OUTPUT-DB-DS;

              uses OUTPUT-LSA-UPDATES-LSA;

              uses INPUT-DB-DS;

              uses INPUT-LSA-UPDATES-LSA;

              uses MANAGEABILITY-PERF-THRESH-CFG-SAMPLE-INTERVAL;

              uses OUTPUT-PACKETS;

              uses INPUT-PACKETS;

              uses OUTPUT-HELLO-PACKETS;

              uses INPUT-HELLO-PACKETS;

              uses OUTPUT-LS-REQUESTS;

              uses OUTPUT-LSA-ACKS-LSA;

              uses OUTPUT-LSA-ACKS;

              uses INPUT-LSA-ACKS;

              uses OUTPUT-LSA-UPDATES;

              uses OUTPUT-LS-REQUESTS-LSA;

              uses INPUT-LS-REQUESTS-LSA;

              uses INPUT-LS-REQUESTS;
            }  // list ospfv3-protocol-template
          }  // container ospfv3-protocol-templates
        }  // container ospfv3-protocol
      }  // container threshold
    }  // container perf-mgmt
  }  // module Cisco-IOS-XR-manageability-perfmgmt-cfg