Cisco-IOS-XR-um-ipsla-cfg

This module contains a collection of YANG definitions for Cisco IOS-XR ipsla package configuration. This YANG module augments t...

  • Version: 2021-02-26

    Cisco-IOS-XR-um-ipsla-cfg@2021-02-26


    
      module Cisco-IOS-XR-um-ipsla-cfg {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XR-um-ipsla-cfg";
    
        prefix um-ipsla-cfg;
    
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import ietf-inet-types {
          prefix inet;
        }
        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 ipsla package configuration.
         
         This YANG module augments the
         modules with configuration data.
         
         Copyright (c) 2021 by Cisco Systems, Inc.
         All rights reserved.";
    
        revision "2021-02-26" {
          description "Initial release";
        }
    
        semver:module-version "1.0.0";
    
        container ipsla {
          description
            "IPSLA configuration commands";
          container operations {
            description
              "IPSLA operation configuration";
            list operation {
              key "operation-number";
              description "Operation number";
              leaf operation-number {
                type uint32 {
                  range "1..2048";
                }
                description "Operation number";
              }
    
              container type {
                description "Type of operation";
                container icmp {
                  description
                    "ICMP operation types";
                  container echo {
                    presence
                      "Indicates a echo node is configured.";
                    description
                      "ICMP echo operation type";
                    leaf tag {
                      type xr:Cisco-ios-xr-string {
                        length "1..128";
                      }
                      description
                        "Add a tag for this operation";
                    }
    
                    leaf frequency {
                      type uint32 {
                        range "1..604800";
                      }
                      description
                        "Frequency of the probing";
                    }
    
                    container datasize {
                      description
                        "Protocol data size in payload of probe packets";
                      container request {
                        description
                          "Payload size in request probe packet";
                        leaf enter-request-datasize-in-byte {
                          type uint32 {
                            range "19..20";
                          }
                          description
                            "Enter request datasize in byte";
                        }
                      }  // container request
                    }  // container datasize
    
                    leaf timeout {
                      type uint32 {
                        range "1..604800000";
                      }
                      description
                        "Probe timeout interval";
                    }
    
                    container source {
                      description
                        "Address/port of the source device";
                      container address {
                        description
                          "IPv4/IPv6 address of the source device";
                        leaf ipv4-address {
                          type inet:ipv4-address-no-zone;
                          description
                            "Enter IPv4 address of the source device";
                        }
    
                        leaf ipv6-address {
                          type inet:ipv6-address-no-zone;
                          description
                            "Enter IPv6 address of the source device";
                        }
                      }  // container address
    
                      leaf port {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Port number on source device";
                      }
                    }  // container source
    
                    leaf tos {
                      type uint32 {
                        range "0..255";
                      }
                      description
                        "Type of service setting in probe packet";
                    }
    
                    leaf vrf {
                      type xr:Cisco-ios-xr-string {
                        length "1..32";
                      }
                      description
                        "Configure IPSLA for a VPN Routing/Forwarding instance";
                    }
    
                    container destination {
                      description
                        "Address/port of the target device";
                      container address {
                        description
                          "IPv4/IPv6 address of the target device";
                        leaf ipv4-address {
                          type inet:ipv4-address-no-zone;
                          description
                            "Enter IPv4 address of the target device";
                        }
    
                        leaf ipv6-address {
                          type inet:ipv6-address-no-zone;
                          description
                            "Enter IPv6 address of the target device";
                        }
                      }  // container address
    
                      leaf port {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Port number on target device";
                      }
                    }  // container destination
                  }  // container echo
    
                  container path-echo {
                    presence
                      "Indicates a path-echo node is configured.";
                    description
                      "ICMP path-echo operation type";
                    leaf tag {
                      type xr:Cisco-ios-xr-string {
                        length "1..128";
                      }
                      description
                        "Add a tag for this operation";
                    }
    
                    leaf frequency {
                      type uint32 {
                        range "1..604800";
                      }
                      description
                        "Frequency of the probing";
                    }
    
                    container datasize {
                      description
                        "Protocol data size in payload of probe packets";
                      container request {
                        description
                          "Payload size in request probe packet";
                        leaf enter-request-datasize-in-byte {
                          type uint32 {
                            range "19..20";
                          }
                          description
                            "Enter request datasize in byte";
                        }
                      }  // container request
                    }  // container datasize
    
                    leaf timeout {
                      type uint32 {
                        range "1..604800000";
                      }
                      description
                        "Probe timeout interval";
                    }
    
                    container source {
                      description
                        "Address/port of the source device";
                      container address {
                        description
                          "IPv4/IPv6 address of the source device";
                        leaf ipv4-address {
                          type inet:ipv4-address-no-zone;
                          description
                            "Enter IPv4 address of the source device";
                        }
    
                        leaf ipv6-address {
                          type inet:ipv6-address-no-zone;
                          description
                            "Enter IPv6 address of the source device";
                        }
                      }  // container address
    
                      leaf port {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Port number on source device";
                      }
                    }  // container source
    
                    container lsr-path {
                      description
                        "Loose source routing path (up to 8 intermediate nodes)";
                      leaf-list ip-address {
                        type inet:ipv4-address-no-zone;
                        must "../ip-address";
                        max-elements 8;
                        description
                          "Enter IPv4 address of the intermediate node";
                      }
                    }  // container lsr-path
    
                    leaf tos {
                      type uint32 {
                        range "0..255";
                      }
                      description
                        "Type of service setting in probe packet";
                    }
                  }  // container path-echo
    
                  container path-jitter {
                    presence
                      "Indicates a path-jitter node is configured.";
                    description
                      "ICMP path-jitter operation type";
                    leaf tag {
                      type xr:Cisco-ios-xr-string {
                        length "1..128";
                      }
                      description
                        "Add a tag for this operation";
                    }
    
                    leaf frequency {
                      type uint32 {
                        range "1..604800";
                      }
                      description
                        "Frequency of the probing";
                    }
    
                    container datasize {
                      description
                        "Protocol data size in payload of probe packets";
                      container request {
                        description
                          "Payload size in request probe packet";
                        leaf enter-request-datasize-in-byte {
                          type uint32 {
                            range "19..20";
                          }
                          description
                            "Enter request datasize in byte";
                        }
                      }  // container request
                    }  // container datasize
    
                    leaf timeout {
                      type uint32 {
                        range "1..604800000";
                      }
                      description
                        "Probe timeout interval";
                    }
    
                    container source {
                      description
                        "Address/port of the source device";
                      container address {
                        description
                          "IPv4/IPv6 address of the source device";
                        leaf ipv4-address {
                          type inet:ipv4-address-no-zone;
                          description
                            "Enter IPv4 address of the source device";
                        }
    
                        leaf ipv6-address {
                          type inet:ipv6-address-no-zone;
                          description
                            "Enter IPv6 address of the source device";
                        }
                      }  // container address
    
                      leaf port {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Port number on source device";
                      }
                    }  // container source
    
                    container packet {
                      description
                        "Probe packet configuration parameters";
                      leaf count {
                        type uint32 {
                          range "1..100";
                        }
                        description
                          "Number of packets to be transmitted during a probe";
                      }
    
                      leaf interval {
                        type uint32 {
                          range "1..60000";
                        }
                        description
                          "Inter packet interval";
                      }
                    }  // container packet
    
                    container lsr-path {
                      description
                        "Loose source routing path (up to 8 intermediate nodes)";
                      leaf-list ip-address {
                        type inet:ipv4-address-no-zone;
                        must "../ip-address";
                        max-elements 8;
                        description
                          "Enter IPv4 address of the intermediate node";
                      }
                    }  // container lsr-path
    
                    leaf tos {
                      type uint32 {
                        range "0..255";
                      }
                      description
                        "Type of service setting in probe packet";
                    }
                  }  // container path-jitter
                }  // container icmp
    
                container udp {
                  description
                    "UDP operation types";
                  container echo {
                    presence
                      "Indicates a echo node is configured.";
                    description
                      "UDP echo operation type";
                    leaf tag {
                      type xr:Cisco-ios-xr-string {
                        length "1..128";
                      }
                      description
                        "Add a tag for this operation";
                    }
    
                    leaf frequency {
                      type uint32 {
                        range "1..604800";
                      }
                      description
                        "Frequency of the probing";
                    }
    
                    container datasize {
                      description
                        "Protocol data size in payload of probe packets";
                      container request {
                        description
                          "Payload size in request probe packet";
                        leaf enter-request-datasize-in-byte {
                          type uint32 {
                            range "19..20";
                          }
                          description
                            "Enter request datasize in byte";
                        }
                      }  // container request
                    }  // container datasize
    
                    leaf timeout {
                      type uint32 {
                        range "1..604800000";
                      }
                      description
                        "Probe timeout interval";
                    }
    
                    container source {
                      description
                        "Address/port of the source device";
                      container address {
                        description
                          "IPv4/IPv6 address of the source device";
                        leaf ipv4-address {
                          type inet:ipv4-address-no-zone;
                          description
                            "Enter IPv4 address of the source device";
                        }
    
                        leaf ipv6-address {
                          type inet:ipv6-address-no-zone;
                          description
                            "Enter IPv6 address of the source device";
                        }
                      }  // container address
    
                      leaf port {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Port number on source device";
                      }
                    }  // container source
    
                    container destination {
                      description
                        "Address/port of the target device";
                      leaf address {
                        type inet:ipv4-address-no-zone;
                        description
                          "IPv4 address of the target device";
                      }
    
                      leaf port {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Port number on target device";
                      }
                    }  // container destination
    
                    container packet {
                      description
                        "Probe packet configuration parameters";
                      leaf count {
                        type uint32 {
                          range "1..100";
                        }
                        description
                          "Number of packets to be transmitted during a probe";
                      }
    
                      leaf interval {
                        type uint32 {
                          range "1..60000";
                        }
                        description
                          "Inter packet interval";
                      }
                    }  // container packet
    
                    container statistics {
                      description
                        "Statistics collection parameters for this operation";
                      container hourly {
                        description
                          "Statistics collection aggregated over an hour";
                        leaf buckets {
                          type uint32 {
                            range "0..25";
                          }
                          description
                            "Number of Hours for which statistics are kept";
                        }
    
                        container distribution {
                          description
                            "Distribution of statistics configuration";
                          leaf count {
                            type uint32 {
                              range "1..20";
                            }
                            description
                              "Count of distribution intervals maintained";
                          }
    
                          leaf interval {
                            type uint32 {
                              range "1..100";
                            }
                            description
                              "Time interval for each statistical distribution";
                          }
                        }  // container distribution
                      }  // container hourly
    
                      container intervals {
                        description
                          "Statistics collection over specified time interval";
                        list interval {
                          key "interval-time";
                          description
                            "Statistics collection over specified time interval";
                          leaf interval-time {
                            type uint32 {
                              range "1..3600";
                            }
                            description
                              "Statistics collection over specified time interval";
                          }
    
                          leaf buckets {
                            type uint32 {
                              range "1..100";
                            }
                            description
                              "Maximum number of buckets to keep";
                          }
                        }  // list interval
                      }  // container intervals
                    }  // container statistics
    
                    container control {
                      description
                        "Control packets configuration";
                      container disable {
                        presence
                          "Indicates a disable node is configured.";
                        description
                          "Disable control packets";
                      }  // container disable
                    }  // container control
    
                    container verify-data {
                      presence
                        "Indicates a verify-data node is configured.";
                      description
                        "Check each IPSLA response for corruption";
                    }  // container verify-data
    
                    leaf vrf {
                      type xr:Cisco-ios-xr-string {
                        length "1..800";
                      }
                      description
                        "Configure IPSLA for a VPN Routing/Forwarding instance";
                    }
    
                    leaf tos {
                      type uint32 {
                        range "0..255";
                      }
                      description
                        "Type of service setting in probe packet";
                    }
    
                    container history {
                      description
                        "Configure the history parameters for this operation";
                      leaf buckets {
                        type uint32 {
                          range "1..60";
                        }
                        description
                          "Buckets of history kept";
                      }
    
                      container filter {
                        description
                          "Criteria to add operation data to history";
                        container all {
                          presence
                            "Indicates an all node is configured.";
                          description
                            "Store history data for all operations";
                        }  // container all
    
                        container failures {
                          presence
                            "Indicates a failures node is configured.";
                          description
                            "Store data for operations that failed";
                        }  // container failures
                      }  // container filter
    
                      leaf lives {
                        type uint32 {
                          range "0..2";
                        }
                        description
                          "Lives of history kept";
                      }
                    }  // container history
                  }  // container echo
    
                  container jitter {
                    presence
                      "Indicates a jitter node is configured.";
                    description
                      "UDP jitter operation type";
                    leaf tag {
                      type xr:Cisco-ios-xr-string {
                        length "1..128";
                      }
                      description
                        "Add a tag for this operation";
                    }
    
                    leaf frequency {
                      type uint32 {
                        range "1..604800";
                      }
                      description
                        "Frequency of the probing";
                    }
    
                    container datasize {
                      description
                        "Protocol data size in payload of probe packets";
                      container request {
                        description
                          "Payload size in request probe packet";
                        leaf enter-request-datasize-in-byte {
                          type uint32 {
                            range "19..20";
                          }
                          description
                            "Enter request datasize in byte";
                        }
                      }  // container request
                    }  // container datasize
    
                    leaf timeout {
                      type uint32 {
                        range "1..604800000";
                      }
                      description
                        "Probe timeout interval";
                    }
    
                    container source {
                      description
                        "Address/port of the source device";
                      container address {
                        description
                          "IPv4/IPv6 address of the source device";
                        leaf ipv4-address {
                          type inet:ipv4-address-no-zone;
                          description
                            "Enter IPv4 address of the source device";
                        }
    
                        leaf ipv6-address {
                          type inet:ipv6-address-no-zone;
                          description
                            "Enter IPv6 address of the source device";
                        }
                      }  // container address
    
                      leaf port {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Port number on source device";
                      }
                    }  // container source
    
                    container destination {
                      description
                        "Address/port of the target device";
                      leaf address {
                        type inet:ipv4-address-no-zone;
                        description
                          "IPv4 address of the target device";
                      }
    
                      leaf port {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Port number on target device";
                      }
                    }  // container destination
    
                    container packet {
                      description
                        "Probe packet configuration parameters";
                      leaf count {
                        type uint32 {
                          range "1..100";
                        }
                        description
                          "Number of packets to be transmitted during a probe";
                      }
    
                      leaf interval {
                        type uint32 {
                          range "1..60000";
                        }
                        description
                          "Inter packet interval";
                      }
                    }  // container packet
    
                    container statistics {
                      description
                        "Statistics collection parameters for this operation";
                      container hourly {
                        description
                          "Statistics collection aggregated over an hour";
                        leaf buckets {
                          type uint32 {
                            range "0..25";
                          }
                          description
                            "Number of Hours for which statistics are kept";
                        }
    
                        container distribution {
                          description
                            "Distribution of statistics configuration";
                          leaf count {
                            type uint32 {
                              range "1..20";
                            }
                            description
                              "Count of distribution intervals maintained";
                          }
    
                          leaf interval {
                            type uint32 {
                              range "1..100";
                            }
                            description
                              "Time interval for each statistical distribution";
                          }
                        }  // container distribution
                      }  // container hourly
    
                      container intervals {
                        description
                          "Statistics collection over specified time interval";
                        list interval {
                          key "interval-time";
                          description
                            "Statistics collection over specified time interval";
                          leaf interval-time {
                            type uint32 {
                              range "1..3600";
                            }
                            description
                              "Statistics collection over specified time interval";
                          }
    
                          leaf buckets {
                            type uint32 {
                              range "1..100";
                            }
                            description
                              "Maximum number of buckets to keep";
                          }
                        }  // list interval
                      }  // container intervals
                    }  // container statistics
    
                    container control {
                      description
                        "Control packets configuration";
                      container disable {
                        presence
                          "Indicates a disable node is configured.";
                        description
                          "Disable control packets";
                      }  // container disable
                    }  // container control
    
                    container verify-data {
                      presence
                        "Indicates a verify-data node is configured.";
                      description
                        "Check each IPSLA response for corruption";
                    }  // container verify-data
    
                    leaf vrf {
                      type xr:Cisco-ios-xr-string {
                        length "1..800";
                      }
                      description
                        "Configure IPSLA for a VPN Routing/Forwarding instance";
                    }
    
                    leaf tos {
                      type uint32 {
                        range "0..255";
                      }
                      description
                        "Type of service setting in probe packet";
                    }
                  }  // container jitter
                }  // container udp
    
                container mpls {
                  description
                    "MPLS operation types";
                  container lsp {
                    description
                      "MPLS LSP operation types";
                    container ping {
                      presence
                        "Indicates a ping node is configured.";
                      description
                        "MPLS Echo operation type";
                      leaf tag {
                        type xr:Cisco-ios-xr-string {
                          length "1..128";
                        }
                        description
                          "Add a tag for this operation";
                      }
    
                      leaf frequency {
                        type uint32 {
                          range "1..604800";
                        }
                        description
                          "Frequency of the probing";
                      }
    
                      container datasize {
                        description
                          "Protocol data size in payload of probe packets";
                        container request {
                          description
                            "Payload size in request probe packet";
                          leaf enter-request-datasize-in-byte {
                            type uint32 {
                              range "19..20";
                            }
                            description
                              "Enter request datasize in byte";
                          }
                        }  // container request
                      }  // container datasize
    
                      leaf timeout {
                        type uint32 {
                          range "1..604800000";
                        }
                        description
                          "Probe timeout interval";
                      }
    
                      container source {
                        description
                          "Address/port of the source device";
                        container address {
                          description
                            "IPv4/IPv6 address of the source device";
                          leaf ipv4-address {
                            type inet:ipv4-address-no-zone;
                            description
                              "Enter IPv4 address of the source device";
                          }
    
                          leaf ipv6-address {
                            type inet:ipv6-address-no-zone;
                            description
                              "Enter IPv6 address of the source device";
                          }
                        }  // container address
    
                        leaf port {
                          type uint32 {
                            range "1..65535";
                          }
                          description
                            "Port number on source device";
                        }
                      }  // container source
    
                      container target {
                        description
                          "Target for the MPLS LSP operation";
                        container ipv4 {
                          presence
                            "Indicates a ipv4 node is configured.";
                          description
                            "Target specified as an IPv4 address";
                          leaf address {
                            type inet:ipv4-address-no-zone;
                            mandatory true;
                            description
                              "Target FEC address with mask";
                          }
    
                          leaf mask {
                            type inet:ipv4-address-no-zone;
                            mandatory true;
                            description
                              "Target FEC address with mask";
                          }
                        }  // container ipv4
    
                        container traffic-eng {
                          description
                            "Traffic engineering target";
                          leaf tunnel {
                            type uint32 {
                              range "0..65535";
                            }
                            description
                              "TE tunnel interface";
                          }
                        }  // container traffic-eng
    
                        container pseudowire {
                          presence
                            "Indicates a pseudowire node is configured.";
                          description
                            "Pseudowire target";
                          leaf address {
                            type inet:ipv4-address-no-zone;
                            mandatory true;
                            description
                              "Pseudowire target";
                          }
    
                          leaf virtual-circuit-id {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            mandatory true;
                            description
                              "Virtual Circuit ID";
                          }
                        }  // container pseudowire
                      }  // container target
                    }  // container ping
    
                    container trace {
                      presence
                        "Indicates a trace node is configured.";
                      description
                        "MPLS Trace operation type";
                      leaf tag {
                        type xr:Cisco-ios-xr-string {
                          length "1..128";
                        }
                        description
                          "Add a tag for this operation";
                      }
    
                      leaf frequency {
                        type uint32 {
                          range "1..604800";
                        }
                        description
                          "Frequency of the probing";
                      }
    
                      container datasize {
                        description
                          "Protocol data size in payload of probe packets";
                        container request {
                          description
                            "Payload size in request probe packet";
                          leaf enter-request-datasize-in-byte {
                            type uint32 {
                              range "19..20";
                            }
                            description
                              "Enter request datasize in byte";
                          }
                        }  // container request
                      }  // container datasize
    
                      leaf timeout {
                        type uint32 {
                          range "1..604800000";
                        }
                        description
                          "Probe timeout interval";
                      }
    
                      container source {
                        description
                          "Address/port of the source device";
                        container address {
                          description
                            "IPv4/IPv6 address of the source device";
                          leaf ipv4-address {
                            type inet:ipv4-address-no-zone;
                            description
                              "Enter IPv4 address of the source device";
                          }
    
                          leaf ipv6-address {
                            type inet:ipv6-address-no-zone;
                            description
                              "Enter IPv6 address of the source device";
                          }
                        }  // container address
    
                        leaf port {
                          type uint32 {
                            range "1..65535";
                          }
                          description
                            "Port number on source device";
                        }
                      }  // container source
    
                      container target {
                        description
                          "Target for the MPLS LSP operation";
                        container ipv4 {
                          presence
                            "Indicates a ipv4 node is configured.";
                          description
                            "Target specified as an IPv4 address";
                          leaf address {
                            type inet:ipv4-address-no-zone;
                            mandatory true;
                            description
                              "Target FEC address with mask";
                          }
    
                          leaf mask {
                            type inet:ipv4-address-no-zone;
                            mandatory true;
                            description
                              "Target FEC address with mask";
                          }
                        }  // container ipv4
    
                        container traffic-eng {
                          description
                            "Traffic engineering target";
                          leaf tunnel {
                            type uint32 {
                              range "0..65535";
                            }
                            description
                              "TE tunnel interface";
                          }
                        }  // container traffic-eng
    
                        container pseudowire {
                          presence
                            "Indicates a pseudowire node is configured.";
                          description
                            "Pseudowire target";
                          leaf address {
                            type inet:ipv4-address-no-zone;
                            mandatory true;
                            description
                              "Pseudowire target";
                          }
    
                          leaf virtual-circuit-id {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            mandatory true;
                            description
                              "Virtual Circuit ID";
                          }
                        }  // container pseudowire
                      }  // container target
                    }  // container trace
                  }  // container lsp
                }  // container mpls
              }  // container type
            }  // list operation
          }  // container operations
    
          container schedule {
            description "Schedule an operation";
            container operations {
              description "Specify an operation";
              list operation {
                key "operation-number";
                description
                  "Specify an operation";
                leaf operation-number {
                  type uint32 {
                    range "1..2048";
                  }
                  description
                    "Specify an operation";
                }
    
                container life {
                  description
                    "Length of the time to execute (default 3600 seconds)";
                  container forever {
                    must
                      "not(../length-of-time)";
                    presence
                      "Indicates a forever node is configured.";
                    description
                      "Schedule operation to run indefinitely";
                  }  // container forever
    
                  leaf length-of-time {
                    type uint32 {
                      range "1..2147483647";
                    }
                    must "not(../forever)";
                    description
                      "Life in seconds. (default 3600 seconds)";
                  }
                }  // container life
    
                container start-time {
                  description
                    "Start time of the operation";
                  container time-and-date {
                    presence
                      "Indicates a time node is configured.";
                    description
                      "Start time of the operation";
                    leaf hour {
                      type uint32 {
                        range "0..23";
                      }
                      mandatory true;
                      description
                        "Time in hh:mm:ss format";
                    }
    
                    leaf minute {
                      type uint32 {
                        range "0..59";
                      }
                      mandatory true;
                      description
                        "Time in hh:mm:ss format";
                    }
    
                    leaf second {
                      type uint32 {
                        range "0..59";
                      }
                      mandatory true;
                      description
                        "Time in hh:mm:ss format";
                    }
    
                    leaf month {
                      type enumeration {
                        enum "january" {
                          value 0;
                          description "January";
                        }
                        enum "february" {
                          value 1;
                          description "February";
                        }
                        enum "march" {
                          value 2;
                          description "March";
                        }
                        enum "april" {
                          value 3;
                          description "April";
                        }
                        enum "may" {
                          value 4;
                          description "May";
                        }
                        enum "june" {
                          value 5;
                          description "June";
                        }
                        enum "july" {
                          value 6;
                          description "July";
                        }
                        enum "august" {
                          value 7;
                          description "August";
                        }
                        enum "september" {
                          value 8;
                          description
                            "September";
                        }
                        enum "october" {
                          value 9;
                          description "October";
                        }
                        enum "november" {
                          value 10;
                          description "November";
                        }
                        enum "december" {
                          value 11;
                          description "December";
                        }
                      }
                      must "../day-of-month";
                      description
                        "Month of the year";
                    }
    
                    leaf day-of-month {
                      type uint32 {
                        range "1..31";
                      }
                      description
                        "Day of the month";
                    }
    
                    leaf year {
                      type uint32 {
                        range "1993..2035";
                      }
                      must
                        "../month and ../day-of-month";
                      description "Year";
                    }
                  }  // container time-and-date
    
                  container pending {
                    presence
                      "Indicates a pending node is configured.";
                    description
                      "Keep operation in the pending state";
                  }  // container pending
    
                  container after {
                    presence
                      "Indicates a after node is configured.";
                    description
                      "Schedule operation after specified time";
                    container time {
                      description
                        "Time in hh:mm:ss format";
                      leaf hour {
                        type uint32 {
                          range "0..23";
                        }
                        mandatory true;
                        description
                          "Time in hh:mm:ss format";
                      }
    
                      leaf minute {
                        type uint32 {
                          range "0..59";
                        }
                        mandatory true;
                        description
                          "Time in hh:mm:ss format";
                      }
    
                      leaf second {
                        type uint32 {
                          range "0..59";
                        }
                        mandatory true;
                        description
                          "Time in hh:mm:ss format";
                      }
                    }  // container time
                  }  // container after
    
                  container now {
                    presence
                      "Indicates a now node is configured.";
                    description
                      "Schedule operation now";
                  }  // container now
                }  // container start-time
    
                container recurring {
                  presence
                    "Indicates a recurring node is configured.";
                  description
                    "probe to be scheduled automatically every day";
                }  // container recurring
    
                leaf ageout {
                  type uint32 {
                    range "0..2073600";
                  }
                  description
                    "How long to keep this entry after it becomes inactive";
                }
              }  // list operation
            }  // container operations
          }  // container schedule
    
          container reaction {
            description
              "IPSLA reaction configuration";
            container operations {
              description
                "Reaction configuration for operation";
              list operation {
                key "operation-number";
                description
                  "Reaction configuration for operation";
                leaf operation-number {
                  type uint32 {
                    range "1..2048";
                  }
                  description
                    "Reaction configuration for operation";
                }
    
                container react {
                  description
                    "Specify an element to be monitored for reaction";
                  container connection-loss {
                    presence
                      "Indicates a connection-loss node is configured.";
                    description
                      "Reaction on connection loss of monitored operation";
                    container threshold {
                      description
                        "Configure threshold parameters on monitored element";
                      container type {
                        description
                          "Threshold type";
                        container immediate {
                          must
                            "not(../consecutive)";
                          presence
                            "Indicates a immediate node is configured.";
                          description
                            "Take action immediately upon threshold violation";
                          leaf average {
                            type uint32 {
                              range "1..16";
                            }
                            description
                              "Take action on average values violate threshold";
                          }
                        }  // container immediate
    
                        leaf consecutive {
                          type uint32 {
                            range "1..16";
                          }
                          must
                            "not(../immediate)";
                          description
                            "Take action after a number of consecutive violations";
                        }
    
                        container xofy {
                          presence
                            "Indicates a xofy node is configured.";
                          description
                            "Take action upon X violations in Y probe operations";
                          leaf x-value {
                            type uint32 {
                              range "1..16";
                            }
                            mandatory true;
                            description
                              "Take action upon X violations in Y probe operations";
                          }
    
                          leaf y-value {
                            type uint32 {
                              range "13..16";
                            }
                            mandatory true;
                            description
                              "Number of probes observing the violations (Y value)";
                          }
                        }  // container xofy
                      }  // container type
                    }  // container threshold
    
                    container action {
                      description
                        "Type of action to be taken on threshold violation(s)";
                      container logging {
                        presence
                          "Indicates a logging node is configured.";
                        description
                          "Generate a syslog alarm on threshold violation";
                      }  // container logging
    
                      container trigger {
                        presence
                          "Indicates a trigger node is configured.";
                        description
                          "Generate trigger to active reaction triggered operation(s)";
                      }  // container trigger
                    }  // container action
                  }  // container connection-loss
    
                  container timeout {
                    presence
                      "Indicates a timeout node is configured.";
                    description
                      "Reaction on timeout of monitored operation";
                    container threshold {
                      description
                        "Configure threshold parameters on monitored element";
                      container type {
                        description
                          "Threshold type";
                        container immediate {
                          must
                            "not(../consecutive)";
                          presence
                            "Indicates a immediate node is configured.";
                          description
                            "Take action immediately upon threshold violation";
                          leaf average {
                            type uint32 {
                              range "1..16";
                            }
                            description
                              "Take action on average values violate threshold";
                          }
                        }  // container immediate
    
                        leaf consecutive {
                          type uint32 {
                            range "1..16";
                          }
                          must
                            "not(../immediate)";
                          description
                            "Take action after a number of consecutive violations";
                        }
    
                        container xofy {
                          presence
                            "Indicates a xofy node is configured.";
                          description
                            "Take action upon X violations in Y probe operations";
                          leaf x-value {
                            type uint32 {
                              range "1..16";
                            }
                            mandatory true;
                            description
                              "Take action upon X violations in Y probe operations";
                          }
    
                          leaf y-value {
                            type uint32 {
                              range "13..16";
                            }
                            mandatory true;
                            description
                              "Number of probes observing the violations (Y value)";
                          }
                        }  // container xofy
                      }  // container type
                    }  // container threshold
    
                    container action {
                      description
                        "Type of action to be taken on threshold violation(s)";
                      container logging {
                        presence
                          "Indicates a logging node is configured.";
                        description
                          "Generate a syslog alarm on threshold violation";
                      }  // container logging
    
                      container trigger {
                        presence
                          "Indicates a trigger node is configured.";
                        description
                          "Generate trigger to active reaction triggered operation(s)";
                      }  // container trigger
                    }  // container action
                  }  // container timeout
    
                  container verify-error {
                    presence
                      "Indicates a verify-error node is configured.";
                    description
                      "Reaction on error verification violation";
                    container threshold {
                      description
                        "Configure threshold parameters on monitored element";
                      container type {
                        description
                          "Threshold type";
                        container immediate {
                          must
                            "not(../consecutive)";
                          presence
                            "Indicates a immediate node is configured.";
                          description
                            "Take action immediately upon threshold violation";
                          leaf average {
                            type uint32 {
                              range "1..16";
                            }
                            description
                              "Take action on average values violate threshold";
                          }
                        }  // container immediate
    
                        leaf consecutive {
                          type uint32 {
                            range "1..16";
                          }
                          must
                            "not(../immediate)";
                          description
                            "Take action after a number of consecutive violations";
                        }
    
                        container xofy {
                          presence
                            "Indicates a xofy node is configured.";
                          description
                            "Take action upon X violations in Y probe operations";
                          leaf x-value {
                            type uint32 {
                              range "1..16";
                            }
                            mandatory true;
                            description
                              "Take action upon X violations in Y probe operations";
                          }
    
                          leaf y-value {
                            type uint32 {
                              range "13..16";
                            }
                            mandatory true;
                            description
                              "Number of probes observing the violations (Y value)";
                          }
                        }  // container xofy
                      }  // container type
                    }  // container threshold
    
                    container action {
                      description
                        "Type of action to be taken on threshold violation(s)";
                      container logging {
                        presence
                          "Indicates a logging node is configured.";
                        description
                          "Generate a syslog alarm on threshold violation";
                      }  // container logging
    
                      container trigger {
                        presence
                          "Indicates a trigger node is configured.";
                        description
                          "Generate trigger to active reaction triggered operation(s)";
                      }  // container trigger
                    }  // container action
                  }  // container verify-error
    
                  container jitter-average {
                    presence
                      "Indicates a jitter-average node is configured.";
                    description
                      "Reaction on round trip jitter value violation";
                    container dest-to-source {
                      presence
                        "Indicates a dest-to-source node is configured.";
                      description
                        "Jitter average destination to source(DS)";
                      container threshold {
                        description
                          "Configure threshold parameters on monitored element";
                        container type {
                          description
                            "Threshold type";
                          container immediate {
                            must
                              "not(../consecutive)";
                            presence
                              "Indicates a immediate node is configured.";
                            description
                              "Take action immediately upon threshold violation";
                            leaf average {
                              type uint32 {
                                range "1..16";
                              }
                              description
                                "Take action on average values violate threshold";
                            }
                          }  // container immediate
    
                          leaf consecutive {
                            type uint32 {
                              range "1..16";
                            }
                            must
                              "not(../immediate)";
                            description
                              "Take action after a number of consecutive violations";
                          }
    
                          container xofy {
                            presence
                              "Indicates a xofy node is configured.";
                            description
                              "Take action upon X violations in Y probe operations";
                            leaf x-value {
                              type uint32 {
                                range "1..16";
                              }
                              mandatory true;
                              description
                                "Take action upon X violations in Y probe operations";
                            }
    
                            leaf y-value {
                              type uint32 {
                                range "13..16";
                              }
                              mandatory true;
                              description
                                "Number of probes observing the violations (Y value)";
                            }
                          }  // container xofy
    
                          leaf lower-limit {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            must
                              "../upper-limit";
                            description
                              "Threshold lower limit";
                          }
    
                          leaf upper-limit {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            must
                              "../lower-limit";
                            description
                              " Threshold upper limit";
                          }
                        }  // container type
                      }  // container threshold
    
                      container action {
                        description
                          "Type of action to be taken on threshold violation(s)";
                        container logging {
                          presence
                            "Indicates a logging node is configured.";
                          description
                            "Generate a syslog alarm on threshold violation";
                        }  // container logging
    
                        container trigger {
                          presence
                            "Indicates a trigger node is configured.";
                          description
                            "Generate trigger to active reaction triggered operation(s)";
                        }  // container trigger
                      }  // container action
                    }  // container dest-to-source
    
                    container source-to-dest {
                      presence
                        "Indicates a source-to-dest node is configured.";
                      description
                        "Jitter average source to destination (SD)";
                      container threshold {
                        description
                          "Configure threshold parameters on monitored element";
                        container type {
                          description
                            "Threshold type";
                          container immediate {
                            must
                              "not(../consecutive)";
                            presence
                              "Indicates a immediate node is configured.";
                            description
                              "Take action immediately upon threshold violation";
                            leaf average {
                              type uint32 {
                                range "1..16";
                              }
                              description
                                "Take action on average values violate threshold";
                            }
                          }  // container immediate
    
                          leaf consecutive {
                            type uint32 {
                              range "1..16";
                            }
                            must
                              "not(../immediate)";
                            description
                              "Take action after a number of consecutive violations";
                          }
    
                          container xofy {
                            presence
                              "Indicates a xofy node is configured.";
                            description
                              "Take action upon X violations in Y probe operations";
                            leaf x-value {
                              type uint32 {
                                range "1..16";
                              }
                              mandatory true;
                              description
                                "Take action upon X violations in Y probe operations";
                            }
    
                            leaf y-value {
                              type uint32 {
                                range "13..16";
                              }
                              mandatory true;
                              description
                                "Number of probes observing the violations (Y value)";
                            }
                          }  // container xofy
    
                          leaf lower-limit {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            must
                              "../upper-limit";
                            description
                              "Threshold lower limit";
                          }
    
                          leaf upper-limit {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            must
                              "../lower-limit";
                            description
                              " Threshold upper limit";
                          }
                        }  // container type
                      }  // container threshold
    
                      container action {
                        description
                          "Type of action to be taken on threshold violation(s)";
                        container logging {
                          presence
                            "Indicates a logging node is configured.";
                          description
                            "Generate a syslog alarm on threshold violation";
                        }  // container logging
    
                        container trigger {
                          presence
                            "Indicates a trigger node is configured.";
                          description
                            "Generate trigger to active reaction triggered operation(s)";
                        }  // container trigger
                      }  // container action
                    }  // container source-to-dest
    
                    container threshold {
                      description
                        "Configure threshold parameters on monitored element";
                      container type {
                        description
                          "Threshold type";
                        container immediate {
                          must
                            "not(../consecutive)";
                          presence
                            "Indicates a immediate node is configured.";
                          description
                            "Take action immediately upon threshold violation";
                          leaf average {
                            type uint32 {
                              range "1..16";
                            }
                            description
                              "Take action on average values violate threshold";
                          }
                        }  // container immediate
    
                        leaf consecutive {
                          type uint32 {
                            range "1..16";
                          }
                          must
                            "not(../immediate)";
                          description
                            "Take action after a number of consecutive violations";
                        }
    
                        container xofy {
                          presence
                            "Indicates a xofy node is configured.";
                          description
                            "Take action upon X violations in Y probe operations";
                          leaf x-value {
                            type uint32 {
                              range "1..16";
                            }
                            mandatory true;
                            description
                              "Take action upon X violations in Y probe operations";
                          }
    
                          leaf y-value {
                            type uint32 {
                              range "13..16";
                            }
                            mandatory true;
                            description
                              "Number of probes observing the violations (Y value)";
                          }
                        }  // container xofy
    
                        leaf lower-limit {
                          type uint32 {
                            range
                              "1..4294967295";
                          }
                          must "../upper-limit";
                          description
                            "Threshold lower limit";
                        }
    
                        leaf upper-limit {
                          type uint32 {
                            range
                              "1..4294967295";
                          }
                          must "../lower-limit";
                          description
                            " Threshold upper limit";
                        }
                      }  // container type
                    }  // container threshold
    
                    container action {
                      description
                        "Type of action to be taken on threshold violation(s)";
                      container logging {
                        presence
                          "Indicates a logging node is configured.";
                        description
                          "Generate a syslog alarm on threshold violation";
                      }  // container logging
    
                      container trigger {
                        presence
                          "Indicates a trigger node is configured.";
                        description
                          "Generate trigger to active reaction triggered operation(s)";
                      }  // container trigger
                    }  // container action
                  }  // container jitter-average
    
                  container packet-loss {
                    description
                      "Reaction on packet loss value violation";
                    container dest-to-source {
                      presence
                        "Indicates a dest-to-source node is configured.";
                      description
                        "Packet loss  destination to source(DS) violation";
                      container threshold {
                        description
                          "Configure threshold parameters on monitored element";
                        container type {
                          description
                            "Threshold type";
                          container immediate {
                            must
                              "not(../consecutive)";
                            presence
                              "Indicates a immediate node is configured.";
                            description
                              "Take action immediately upon threshold violation";
                            leaf average {
                              type uint32 {
                                range "1..16";
                              }
                              description
                                "Take action on average values violate threshold";
                            }
                          }  // container immediate
    
                          leaf consecutive {
                            type uint32 {
                              range "1..16";
                            }
                            must
                              "not(../immediate)";
                            description
                              "Take action after a number of consecutive violations";
                          }
    
                          container xofy {
                            presence
                              "Indicates a xofy node is configured.";
                            description
                              "Take action upon X violations in Y probe operations";
                            leaf x-value {
                              type uint32 {
                                range "1..16";
                              }
                              mandatory true;
                              description
                                "Take action upon X violations in Y probe operations";
                            }
    
                            leaf y-value {
                              type uint32 {
                                range "13..16";
                              }
                              mandatory true;
                              description
                                "Number of probes observing the violations (Y value)";
                            }
                          }  // container xofy
    
                          leaf lower-limit {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            must
                              "../upper-limit";
                            description
                              "Threshold lower limit";
                          }
    
                          leaf upper-limit {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            must
                              "../lower-limit";
                            description
                              " Threshold upper limit";
                          }
                        }  // container type
                      }  // container threshold
    
                      container action {
                        description
                          "Type of action to be taken on threshold violation(s)";
                        container logging {
                          presence
                            "Indicates a logging node is configured.";
                          description
                            "Generate a syslog alarm on threshold violation";
                        }  // container logging
    
                        container trigger {
                          presence
                            "Indicates a trigger node is configured.";
                          description
                            "Generate trigger to active reaction triggered operation(s)";
                        }  // container trigger
                      }  // container action
                    }  // container dest-to-source
    
                    container source-to-dest {
                      presence
                        "Indicates a source-to-dest node is configured.";
                      description
                        "Packet loss source to destination (SD) violation";
                      container threshold {
                        description
                          "Configure threshold parameters on monitored element";
                        container type {
                          description
                            "Threshold type";
                          container immediate {
                            must
                              "not(../consecutive)";
                            presence
                              "Indicates a immediate node is configured.";
                            description
                              "Take action immediately upon threshold violation";
                            leaf average {
                              type uint32 {
                                range "1..16";
                              }
                              description
                                "Take action on average values violate threshold";
                            }
                          }  // container immediate
    
                          leaf consecutive {
                            type uint32 {
                              range "1..16";
                            }
                            must
                              "not(../immediate)";
                            description
                              "Take action after a number of consecutive violations";
                          }
    
                          container xofy {
                            presence
                              "Indicates a xofy node is configured.";
                            description
                              "Take action upon X violations in Y probe operations";
                            leaf x-value {
                              type uint32 {
                                range "1..16";
                              }
                              mandatory true;
                              description
                                "Take action upon X violations in Y probe operations";
                            }
    
                            leaf y-value {
                              type uint32 {
                                range "13..16";
                              }
                              mandatory true;
                              description
                                "Number of probes observing the violations (Y value)";
                            }
                          }  // container xofy
    
                          leaf lower-limit {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            must
                              "../upper-limit";
                            description
                              "Threshold lower limit";
                          }
    
                          leaf upper-limit {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            must
                              "../lower-limit";
                            description
                              " Threshold upper limit";
                          }
                        }  // container type
                      }  // container threshold
    
                      container action {
                        description
                          "Type of action to be taken on threshold violation(s)";
                        container logging {
                          presence
                            "Indicates a logging node is configured.";
                          description
                            "Generate a syslog alarm on threshold violation";
                        }  // container logging
    
                        container trigger {
                          presence
                            "Indicates a trigger node is configured.";
                          description
                            "Generate trigger to active reaction triggered operation(s)";
                        }  // container trigger
                      }  // container action
                    }  // container source-to-dest
                  }  // container packet-loss
    
                  container rtt {
                    presence
                      "Indicates a rtt node is configured.";
                    description
                      "Reaction on round trip time violation";
                    container threshold {
                      description
                        "Configure threshold parameters on monitored element";
                      container type {
                        description
                          "Threshold type";
                        container immediate {
                          must
                            "not(../consecutive)";
                          presence
                            "Indicates a immediate node is configured.";
                          description
                            "Take action immediately upon threshold violation";
                          leaf average {
                            type uint32 {
                              range "1..16";
                            }
                            description
                              "Take action on average values violate threshold";
                          }
                        }  // container immediate
    
                        leaf consecutive {
                          type uint32 {
                            range "1..16";
                          }
                          must
                            "not(../immediate)";
                          description
                            "Take action after a number of consecutive violations";
                        }
    
                        container xofy {
                          presence
                            "Indicates a xofy node is configured.";
                          description
                            "Take action upon X violations in Y probe operations";
                          leaf x-value {
                            type uint32 {
                              range "1..16";
                            }
                            mandatory true;
                            description
                              "Take action upon X violations in Y probe operations";
                          }
    
                          leaf y-value {
                            type uint32 {
                              range "13..16";
                            }
                            mandatory true;
                            description
                              "Number of probes observing the violations (Y value)";
                          }
                        }  // container xofy
    
                        leaf lower-limit {
                          type uint32 {
                            range
                              "1..4294967295";
                          }
                          must "../upper-limit";
                          description
                            "Threshold lower limit";
                        }
    
                        leaf upper-limit {
                          type uint32 {
                            range
                              "1..4294967295";
                          }
                          must "../lower-limit";
                          description
                            " Threshold upper limit";
                        }
                      }  // container type
                    }  // container threshold
    
                    container action {
                      description
                        "Type of action to be taken on threshold violation(s)";
                      container logging {
                        presence
                          "Indicates a logging node is configured.";
                        description
                          "Generate a syslog alarm on threshold violation";
                      }  // container logging
    
                      container trigger {
                        presence
                          "Indicates a trigger node is configured.";
                        description
                          "Generate trigger to active reaction triggered operation(s)";
                      }  // container trigger
                    }  // container action
                  }  // container rtt
                }  // container react
              }  // list operation
            }  // container operations
    
            container trigger {
              description
                "IPSLA reaction trigger configuration";
              container operations {
                description
                  "Operation that generates a trigger";
                list operation {
                  key "operation-number";
                  description
                    "Operation that generates a trigger";
                  leaf operation-number {
                    type uint32 {
                      range "1..2048";
                    }
                    description
                      "Operation that generates a trigger";
                  }
    
                  leaf operation-to-be-triggered {
                    type uint32 {
                      range "1..2048";
                    }
                    mandatory true;
                    description
                      "Operation that will be triggered";
                  }
                }  // list operation
              }  // container operations
            }  // container trigger
          }  // container reaction
    
          leaf low-memory {
            type uint32 {
              range "0..4294967295";
            }
            description
              "Configure low memory water mark (default 20M)";
          }
    
          leaf key-chain {
            type xr:Cisco-ios-xr-string {
              length "1..32";
            }
            description
              "Use MD5 authentication for IPSLA control message";
          }
    
          container hw-timestamp {
            description
              "Hardware timestamp configuration";
            container disable {
              presence
                "Indicates a disable node is configured.";
              description
                "Disable hardware timestamp";
            }  // container disable
          }  // container hw-timestamp
    
          container responder {
            presence
              "Indicates a responder node is configured.";
            description
              "IPSLA responder configuration";
            container type {
              description "Operation type";
              container udp {
                description "Udp operation";
                container ipv4 {
                  description
                    "IPv4 address configuration";
                  list address {
                    key "address";
                    description
                      "Permanent address on responder";
                    leaf address {
                      type inet:ipv4-address-no-zone;
                      description
                        "Permanent address on responder";
                    }
    
                    list port {
                      key "port-number";
                      description
                        "Permanent port on responder";
                      leaf port-number {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Permanent port on responder";
                      }
                    }  // list port
                  }  // list address
                }  // container ipv4
              }  // container udp
            }  // container type
    
            container twamp {
              presence
                "Indicates a twamp node is configured.";
              description
                "Setup TWAMP responder";
              leaf timeout {
                type uint32 {
                  range "1..604800";
                }
                description
                  "Inactivity timeout period";
              }
            }  // container twamp
    
            container twamp-light {
              description
                "Setup TWAMP-LIGHT responder";
              container test-session {
                description
                  "Create a new test session";
                list session {
                  key "session-id";
                  description "Test session ID";
                  leaf session-id {
                    type uint32 {
                      range "1..65535";
                    }
                    description
                      "Test session ID";
                  }
    
                  container local-ip {
                    description
                      "Local interface IPv4/IPv6 address";
                    container ipv4-addresses {
                      description
                        "Enter IPv4 address of the local interface";
                      list ipv4-address {
                        key "address local-port";
                        description
                          "Enter IPv4 address of the local interface";
                        leaf address {
                          type inet:ipv4-address-no-zone;
                          description
                            "Enter IPv4 address of the local interface";
                        }
    
                        leaf local-port {
                          type uint32 {
                            range "1..65535";
                          }
                          description
                            "Local UDP port";
                        }
    
                        container remote-ip {
                          description
                            "Remote (client) interface IPv4/IPv6 address";
                          container ipv4-addresses {
                            description
                              "Enter IPv4 address of the remote interface";
                            list ipv4-address {
                              key "address remote-port vrf";
                              description
                                "Enter IPv4 address of the remote interface";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Enter IPv4 address of the remote interface";
                              }
    
                              leaf remote-port {
                                type uint32 {
                                  range
                                    "1..65535";
                                }
                                description
                                  "Remote UDP port";
                              }
    
                              leaf vrf {
                                type union {
                                  type xr:Cisco-ios-xr-string {
                                    pattern
                                      "default";
                                  }
                                  type xr:Cisco-ios-xr-string {
                                    length
                                      "1..32";
                                  }
                                }
                                description
                                  "VRF name for local-ip";
                              }
                            }  // list ipv4-address
                          }  // container ipv4-addresses
    
                          container ipv6-addresses {
                            description
                              "Enter IPv6 address of the remote interface";
                            list ipv6-address {
                              key "address remote-port vrf";
                              description
                                "Enter IPv6 address of the remote interface";
                              leaf address {
                                type inet:ipv6-address-no-zone;
                                description
                                  "Enter IPv6 address of the remote interface";
                              }
    
                              leaf remote-port {
                                type uint32 {
                                  range
                                    "1..65535";
                                }
                                description
                                  "Remote UDP port";
                              }
    
                              leaf vrf {
                                type union {
                                  type xr:Cisco-ios-xr-string {
                                    pattern
                                      "default";
                                  }
                                  type xr:Cisco-ios-xr-string {
                                    length
                                      "1..32";
                                  }
                                }
                                description
                                  "VRF name for local-ip";
                              }
                            }  // list ipv6-address
                          }  // container ipv6-addresses
                        }  // container remote-ip
                      }  // list ipv4-address
                    }  // container ipv4-addresses
    
                    container ipv6-addresses {
                      description
                        "Enter IPv6 address of the local interface";
                      list ipv6-address {
                        key "address local-port";
                        description
                          "Enter IPv6 address of the local interface";
                        leaf address {
                          type inet:ipv6-address-no-zone;
                          description
                            "Enter IPv6 address of the local interface";
                        }
    
                        leaf local-port {
                          type uint32 {
                            range "1..65535";
                          }
                          description
                            "Local UDP port";
                        }
    
                        container remote-ip {
                          description
                            "Remote (client) interface IPv4/IPv6 address";
                          container ipv4-addresses {
                            description
                              "Enter IPv4 address of the remote interface";
                            list ipv4-address {
                              key "address remote-port vrf";
                              description
                                "Enter IPv4 address of the remote interface";
                              leaf address {
                                type inet:ipv4-address-no-zone;
                                description
                                  "Enter IPv4 address of the remote interface";
                              }
    
                              leaf remote-port {
                                type uint32 {
                                  range
                                    "1..65535";
                                }
                                description
                                  "Remote UDP port";
                              }
    
                              leaf vrf {
                                type union {
                                  type xr:Cisco-ios-xr-string {
                                    pattern
                                      "default";
                                  }
                                  type xr:Cisco-ios-xr-string {
                                    length
                                      "1..32";
                                  }
                                }
                                description
                                  "VRF name for local-ip";
                              }
                            }  // list ipv4-address
                          }  // container ipv4-addresses
    
                          container ipv6-addresses {
                            description
                              "Enter IPv6 address of the remote interface";
                            list ipv6-address {
                              key "address remote-port vrf";
                              description
                                "Enter IPv6 address of the remote interface";
                              leaf address {
                                type inet:ipv6-address-no-zone;
                                description
                                  "Enter IPv6 address of the remote interface";
                              }
    
                              leaf remote-port {
                                type uint32 {
                                  range
                                    "1..65535";
                                }
                                description
                                  "Remote UDP port";
                              }
    
                              leaf vrf {
                                type union {
                                  type xr:Cisco-ios-xr-string {
                                    pattern
                                      "default";
                                  }
                                  type xr:Cisco-ios-xr-string {
                                    length
                                      "1..32";
                                  }
                                }
                                description
                                  "VRF name for local-ip";
                              }
                            }  // list ipv6-address
                          }  // container ipv6-addresses
                        }  // container remote-ip
                      }  // list ipv6-address
                    }  // container ipv6-addresses
                  }  // container local-ip
    
                  container authentication {
                    presence
                      "Indicates a authentication node is configured.";
                    description
                      "Authenticated test session";
                  }  // container authentication
    
                  container encryption {
                    presence
                      "Indicates a encryption node is configured.";
                    description
                      "Encrypted test session";
                  }  // container encryption
    
                  leaf timeout {
                    type uint32 {
                      range "60..86400";
                    }
                    description
                      "Duration for which session remains active (in seconds). Default is forever.";
                  }
                }  // list session
              }  // container test-session
            }  // container twamp-light
          }  // container responder
    
          container mpls {
            description
              "IPSLA MPLS configuration";
            container lsp-monitor {
              description
                "MPLS LSP Monitor(MPLSLM) configuration";
              container monitors {
                description
                  "MPLSLM instance to be configured";
                list monitor {
                  key "monitor-id";
                  description
                    "MPLSLM instance to be configured";
                  leaf monitor-id {
                    type uint32 {
                      range "1..2048";
                    }
                    description
                      "MPLSLM instance to be configured";
                  }
    
                  container type {
                    description
                      "Type of operation";
                    container mpls {
                      description
                        "MPLS operation types";
                      container lsp {
                        description
                          "MPLS LSP operation types";
                        container ping {
                          presence
                            "Indicates a ping node is configured.";
                          description
                            "Perform MPLS LSP Ping operation";
                          leaf vrf {
                            type xr:Cisco-ios-xr-string {
                              length "1..32";
                            }
                            description
                              "Specify a VRF instance to be monitored";
                          }
    
                          leaf access-list {
                            type xr:Cisco-ios-xr-string {
                              length "1..32";
                            }
                            description
                              "Apply access list to filter PE addresses";
                          }
    
                          container scan {
                            description
                              "Scanning parameters configuration";
                            leaf interval {
                              type uint32 {
                                range "1..70560";
                              }
                              description
                                "Time interval for automatic discovery";
                            }
    
                            leaf delete-factor {
                              type uint32 {
                                range
                                  "0..2147483647";
                              }
                              description
                                "Number of times for automatic deletion";
                            }
                          }  // container scan
    
                          leaf tag {
                            type xr:Cisco-ios-xr-string {
                              length "1..128";
                            }
                            description
                              "Add a tag for this MPLSLM";
                          }
    
                          container datasize {
                            description
                              "Protocol data size in payload of probe packets";
                            leaf request {
                              type uint32 {
                                range
                                  "100..17986";
                              }
                              description
                                "Payload size in request probe packet";
                            }
                          }  // container datasize
    
                          leaf timeout {
                            type uint32 {
                              range
                                "1..604800000";
                            }
                            description
                              "Probe/Control timeout interval";
                          }
    
                          container lsp {
                            description
                              "LSP parameters for the operation";
                            container selector {
                              description
                                "Attributes used for path selection during LSP load balancing";
                              leaf ipv4 {
                                type inet:ipv4-address-no-zone;
                                description
                                  "IPv4 address used as destination address in echo request";
                              }
                            }  // container selector
                          }  // container lsp
    
                          container force {
                            description
                              "Forced option for the MPLS LSP operation";
                            container explicit-null {
                              presence
                                "Indicates a explicit-null node is configured.";
                              description
                                "Add Explicit Null label to the stack";
                            }  // container explicit-null
                          }  // container force
    
                          container reply {
                            description
                              "Echo reply options for the MPLS LSP operation";
                            leaf dscp {
                              type union {
                                type uint32 {
                                  range "0..63";
                                }
                                type enumeration {
                                  enum "default" {
                                    value 0;
                                    description
                                      "Match packets with default dscp (000000)";
                                  }
                                  enum "cs1" {
                                    value 8;
                                    description
                                      "Match packets with CS1(precedence 1) dscp (001000)";
                                  }
                                  enum "af11" {
                                    value 10;
                                    description
                                      "Match packets with AF11 dscp (001010)";
                                  }
                                  enum "af12" {
                                    value 12;
                                    description
                                      "Match packets with AF12 dscp (001100)";
                                  }
                                  enum "af13" {
                                    value 14;
                                    description
                                      "Match packets with AF13 dscp (001110)";
                                  }
                                  enum "cs2" {
                                    value 16;
                                    description
                                      "Match packets with CS2(precedence 2) dscp (010000)";
                                  }
                                  enum "af21" {
                                    value 18;
                                    description
                                      "Match packets with AF21 dscp (010010)";
                                  }
                                  enum "af22" {
                                    value 20;
                                    description
                                      "Match packets with AF22 dscp (010100)";
                                  }
                                  enum "af23" {
                                    value 22;
                                    description
                                      "Match packets with AF23 dscp (010110)";
                                  }
                                  enum "cs3" {
                                    value 24;
                                    description
                                      "Match packets with CS3(precedence 3) dscp (011000)";
                                  }
                                  enum "af31" {
                                    value 26;
                                    description
                                      "Match packets with AF31 dscp (011010)";
                                  }
                                  enum "af32" {
                                    value 28;
                                    description
                                      "Match packets with AF32 dscp (011100)";
                                  }
                                  enum "af33" {
                                    value 30;
                                    description
                                      "Match packets with AF33 dscp (011110)";
                                  }
                                  enum "cs4" {
                                    value 32;
                                    description
                                      "Match packets with CS4(precedence 4) dscp (100000)";
                                  }
                                  enum "af41" {
                                    value 34;
                                    description
                                      "Match packets with AF41 dscp (100010)";
                                  }
                                  enum "af42" {
                                    value 36;
                                    description
                                      "Match packets with AF42 dscp (100100)";
                                  }
                                  enum "af43" {
                                    value 38;
                                    description
                                      "Match packets with AF43 dscp (100110)";
                                  }
                                  enum "cs5" {
                                    value 40;
                                    description
                                      "Match packets with CS5(precedence 5) dscp (101000)";
                                  }
                                  enum "ef" {
                                    value 46;
                                    description
                                      "Match packets with EF dscp (101110)";
                                  }
                                  enum "cs6" {
                                    value 48;
                                    description
                                      "Match packets with CS6(precedence 6) dscp (110000)";
                                  }
                                  enum "cs7" {
                                    value 56;
                                    description
                                      "Match packets with CS7(precedence 7) dscp (111000)";
                                  }
                                }
                              }
                              description
                                "DSCP bits in the reply IP header";
                            }
    
                            container mode {
                              description
                                "Configures reply mode parameters";
                              container router-alert {
                                presence
                                  "Indicates a router-alert node is configured.";
                                description
                                  "Enables use of router alert in echo reply packets";
                              }  // container router-alert
                            }  // container mode
                          }  // container reply
    
                          leaf ttl {
                            type uint32 {
                              range "1..255";
                            }
                            description
                              "Time to live";
                          }
    
                          leaf exp {
                            type uint32 {
                              range "0..7";
                            }
                            description
                              "EXP in MPLS LSP echo request header";
                          }
    
                          container output {
                            description
                              "Output options";
                            leaf interface {
                              type xr:Interface-name;
                              description
                                "Output interface to be used for measurement";
                            }
    
                            leaf nexthop {
                              type inet:ipv4-address-no-zone;
                              description
                                "Output nexthop to be used for measurement";
                            }
                          }  // container output
    
                          container path {
                            description
                              "Path discover configuration";
                            container discover {
                              presence
                                "Indicates a discover node is configured.";
                              description
                                "Enable MPLS LSP path discover(LPD)";
                              container session {
                                description
                                  "Session parameters configuration";
                                leaf limit {
                                  type uint32 {
                                    range
                                      "1..15";
                                  }
                                  description
                                    "Number of concurrent active path discovery requests at one time";
                                }
    
                                leaf timeout {
                                  type uint32 {
                                    range
                                      "1..900";
                                  }
                                  description
                                    "Timeout value for path discovery request";
                                }
                              }  // container session
    
                              container scan {
                                description
                                  "Scan parameters configuration";
                                leaf period {
                                  type uint32 {
                                    range
                                      "0..7200";
                                  }
                                  description
                                    "Time period for finishing path discovery";
                                }
                              }  // container scan
    
                              container path {
                                description
                                  "Path parameters configuration";
                                leaf retry {
                                  type uint32 {
                                    range
                                      "1..16";
                                  }
                                  description
                                    "Number of attempts before declaring the path as down";
                                }
    
                                container secondary {
                                  description
                                    "Secondary frequency configuration";
                                  container frequency {
                                    description
                                      "Frequency to be used if path failure condition is detected";
                                    container both {
                                      must
                                        "not(../timeout or ../connection-loss)";
                                      presence
                                        "Indicates a both node is configured.";
                                      description
                                        "Enable secondary frequency for timeout and connection loss";
                                      leaf frequency-value-in-seconds {
                                        type uint32 {
                                          range
                                            "1..604800";
                                        }
                                        mandatory
                                          true;
                                        description
                                          "Frequency value in seconds";
                                      }
                                    }  // container both
    
                                    container connection-loss {
                                      must
                                        "not(../both or ../timeout)";
                                      presence
                                        "Indicates a connection-loss node is configured.";
                                      description
                                        "Enable secondary frequency for connection loss";
                                      leaf frequency-value-in-seconds {
                                        type uint32 {
                                          range
                                            "1..604800";
                                        }
                                        mandatory
                                          true;
                                        description
                                          "Frequency value in seconds";
                                      }
                                    }  // container connection-loss
    
                                    container timeout {
                                      must
                                        "not(../both or ../connection-loss)";
                                      presence
                                        "Indicates a timeout node is configured.";
                                      description
                                        "Enable secondary frequency for timeout";
                                      leaf frequency-value-in-seconds {
                                        type uint32 {
                                          range
                                            "1..604800";
                                        }
                                        mandatory
                                          true;
                                        description
                                          "Frequency value in seconds";
                                      }
                                    }  // container timeout
                                  }  // container frequency
                                }  // container secondary
                              }  // container path
    
                              container echo {
                                description
                                  "Echo parameters configuration";
                                leaf interval {
                                  type uint32 {
                                    range
                                      "0..3600000";
                                  }
                                  description
                                    "Send interval between echo requests during path discovery";
                                }
    
                                leaf timeout {
                                  type uint32 {
                                    range
                                      "1..3600";
                                  }
                                  description
                                    "Timeout value for echo requests during path discovery";
                                }
    
                                leaf retry {
                                  type uint32 {
                                    range
                                      "0..10";
                                  }
                                  description
                                    "Number of timeout retry attempts during path discovery";
                                }
    
                                container multipath {
                                  description
                                    "Downstream map multipath settings";
                                  leaf bitmap-size {
                                    type uint32 {
                                      range
                                        "1..256";
                                    }
                                    description
                                      "Multipath bit size";
                                  }
                                }  // container multipath
    
                                container maximum {
                                  description
                                    "Maximum value settings";
                                  container lsp {
                                    description
                                      "LSP parameters for the operation";
                                    container selector {
                                      description
                                        "Attributes used for path selection during LSP load balancing";
                                      leaf ipv4 {
                                        type inet:ipv4-address-no-zone;
                                        description
                                          "Maximum IPv4 address used as destination in echo request";
                                      }
                                    }  // container selector
                                  }  // container lsp
                                }  // container maximum
                              }  // container echo
                            }  // container discover
                          }  // container path
    
                          container statistics {
                            description
                              "Statistics collection parameters for this operation";
                            container hourly {
                              description
                                "Statistics collection aggregated over an hour";
                              leaf buckets {
                                type uint32 {
                                  range "0..2";
                                }
                                description
                                  "Number of Hours for which statistics are kept";
                              }
                            }  // container hourly
                          }  // container statistics
                        }  // container ping
    
                        container trace {
                          presence
                            "Indicates a trace node is configured.";
                          description
                            "Perform MPLS LSP Trace operation";
                          leaf vrf {
                            type xr:Cisco-ios-xr-string {
                              length "1..32";
                            }
                            description
                              "Specify a VRF instance to be monitored";
                          }
    
                          leaf access-list {
                            type xr:Cisco-ios-xr-string {
                              length "1..32";
                            }
                            description
                              "Apply access list to filter PE addresses";
                          }
    
                          container scan {
                            description
                              "Scanning parameters configuration";
                            leaf interval {
                              type uint32 {
                                range "1..70560";
                              }
                              description
                                "Time interval for automatic discovery";
                            }
    
                            leaf delete-factor {
                              type uint32 {
                                range
                                  "0..2147483647";
                              }
                              description
                                "Number of times for automatic deletion";
                            }
                          }  // container scan
    
                          leaf tag {
                            type xr:Cisco-ios-xr-string {
                              length "1..128";
                            }
                            description
                              "Add a tag for this MPLSLM";
                          }
    
                          container datasize {
                            description
                              "Protocol data size in payload of probe packets";
                            leaf request {
                              type uint32 {
                                range
                                  "100..17986";
                              }
                              description
                                "Payload size in request probe packet";
                            }
                          }  // container datasize
    
                          leaf timeout {
                            type uint32 {
                              range
                                "1..604800000";
                            }
                            description
                              "Probe/Control timeout interval";
                          }
    
                          container lsp {
                            description
                              "LSP parameters for the operation";
                            container selector {
                              description
                                "Attributes used for path selection during LSP load balancing";
                              leaf ipv4 {
                                type inet:ipv4-address-no-zone;
                                description
                                  "IPv4 address used as destination address in echo request";
                              }
                            }  // container selector
                          }  // container lsp
    
                          container force {
                            description
                              "Forced option for the MPLS LSP operation";
                            container explicit-null {
                              presence
                                "Indicates a explicit-null node is configured.";
                              description
                                "Add Explicit Null label to the stack";
                            }  // container explicit-null
                          }  // container force
    
                          container reply {
                            description
                              "Echo reply options for the MPLS LSP operation";
                            leaf dscp {
                              type union {
                                type uint32 {
                                  range "0..63";
                                }
                                type enumeration {
                                  enum "default" {
                                    value 0;
                                    description
                                      "Match packets with default dscp (000000)";
                                  }
                                  enum "cs1" {
                                    value 8;
                                    description
                                      "Match packets with CS1(precedence 1) dscp (001000)";
                                  }
                                  enum "af11" {
                                    value 10;
                                    description
                                      "Match packets with AF11 dscp (001010)";
                                  }
                                  enum "af12" {
                                    value 12;
                                    description
                                      "Match packets with AF12 dscp (001100)";
                                  }
                                  enum "af13" {
                                    value 14;
                                    description
                                      "Match packets with AF13 dscp (001110)";
                                  }
                                  enum "cs2" {
                                    value 16;
                                    description
                                      "Match packets with CS2(precedence 2) dscp (010000)";
                                  }
                                  enum "af21" {
                                    value 18;
                                    description
                                      "Match packets with AF21 dscp (010010)";
                                  }
                                  enum "af22" {
                                    value 20;
                                    description
                                      "Match packets with AF22 dscp (010100)";
                                  }
                                  enum "af23" {
                                    value 22;
                                    description
                                      "Match packets with AF23 dscp (010110)";
                                  }
                                  enum "cs3" {
                                    value 24;
                                    description
                                      "Match packets with CS3(precedence 3) dscp (011000)";
                                  }
                                  enum "af31" {
                                    value 26;
                                    description
                                      "Match packets with AF31 dscp (011010)";
                                  }
                                  enum "af32" {
                                    value 28;
                                    description
                                      "Match packets with AF32 dscp (011100)";
                                  }
                                  enum "af33" {
                                    value 30;
                                    description
                                      "Match packets with AF33 dscp (011110)";
                                  }
                                  enum "cs4" {
                                    value 32;
                                    description
                                      "Match packets with CS4(precedence 4) dscp (100000)";
                                  }
                                  enum "af41" {
                                    value 34;
                                    description
                                      "Match packets with AF41 dscp (100010)";
                                  }
                                  enum "af42" {
                                    value 36;
                                    description
                                      "Match packets with AF42 dscp (100100)";
                                  }
                                  enum "af43" {
                                    value 38;
                                    description
                                      "Match packets with AF43 dscp (100110)";
                                  }
                                  enum "cs5" {
                                    value 40;
                                    description
                                      "Match packets with CS5(precedence 5) dscp (101000)";
                                  }
                                  enum "ef" {
                                    value 46;
                                    description
                                      "Match packets with EF dscp (101110)";
                                  }
                                  enum "cs6" {
                                    value 48;
                                    description
                                      "Match packets with CS6(precedence 6) dscp (110000)";
                                  }
                                  enum "cs7" {
                                    value 56;
                                    description
                                      "Match packets with CS7(precedence 7) dscp (111000)";
                                  }
                                }
                              }
                              description
                                "DSCP bits in the reply IP header";
                            }
    
                            container mode {
                              description
                                "Configures reply mode parameters";
                              container router-alert {
                                presence
                                  "Indicates a router-alert node is configured.";
                                description
                                  "Enables use of router alert in echo reply packets";
                              }  // container router-alert
                            }  // container mode
                          }  // container reply
    
                          leaf ttl {
                            type uint32 {
                              range "1..255";
                            }
                            description
                              "Time to live";
                          }
    
                          leaf exp {
                            type uint32 {
                              range "0..7";
                            }
                            description
                              "EXP in MPLS LSP echo request header";
                          }
    
                          container output {
                            description
                              "Output options";
                            leaf interface {
                              type xr:Interface-name;
                              description
                                "Output interface to be used for measurement";
                            }
    
                            leaf nexthop {
                              type inet:ipv4-address-no-zone;
                              description
                                "Output nexthop to be used for measurement";
                            }
                          }  // container output
    
                          container statistics {
                            description
                              "Statistics collection parameters for this operation";
                            container hourly {
                              description
                                "Statistics collection aggregated over an hour";
                              leaf buckets {
                                type uint32 {
                                  range "0..2";
                                }
                                description
                                  "Number of Hours for which statistics are kept";
                              }
                            }  // container hourly
                          }  // container statistics
                        }  // container trace
                      }  // container lsp
                    }  // container mpls
                  }  // container type
                }  // list monitor
              }  // container monitors
    
              container schedule {
                description
                  "MPLSLM schedule configuration";
                container monitors {
                  description
                    "MPLSLM instance to be configured";
                  list monitor {
                    key "monitor-id";
                    description
                      "MPLSLM instance to be configured";
                    leaf monitor-id {
                      type uint32 {
                        range "1..2048";
                      }
                      description
                        "MPLSLM instance to be configured";
                    }
    
                    container schedule {
                      description
                        "Schedule parameters configuration";
                      leaf period {
                        type uint32 {
                          range "1..604800";
                        }
                        description
                          "Group schedule period range";
                      }
                    }  // container schedule
    
                    leaf frequency {
                      type uint32 {
                        range "1..604800";
                      }
                      description
                        "Group schedule frequency of the probing";
                    }
    
                    container start-time {
                      description
                        "Start time of the operation";
                      container time-and-date {
                        presence
                          "Indicates a time node is configured.";
                        description
                          "Start time of the operation";
                        leaf hour {
                          type uint32 {
                            range "0..23";
                          }
                          mandatory true;
                          description
                            "Time in hh:mm:ss format";
                        }
    
                        leaf minute {
                          type uint32 {
                            range "0..59";
                          }
                          mandatory true;
                          description
                            "Time in hh:mm:ss format";
                        }
    
                        leaf second {
                          type uint32 {
                            range "0..59";
                          }
                          mandatory true;
                          description
                            "Time in hh:mm:ss format";
                        }
    
                        leaf month {
                          type enumeration {
                            enum "january" {
                              value 0;
                              description
                                "January";
                            }
                            enum "february" {
                              value 1;
                              description
                                "February";
                            }
                            enum "march" {
                              value 2;
                              description
                                "March";
                            }
                            enum "april" {
                              value 3;
                              description
                                "April";
                            }
                            enum "may" {
                              value 4;
                              description "May";
                            }
                            enum "june" {
                              value 5;
                              description "June";
                            }
                            enum "july" {
                              value 6;
                              description "July";
                            }
                            enum "august" {
                              value 7;
                              description
                                "August";
                            }
                            enum "september" {
                              value 8;
                              description
                                "September";
                            }
                            enum "october" {
                              value 9;
                              description
                                "October";
                            }
                            enum "november" {
                              value 10;
                              description
                                "November";
                            }
                            enum "december" {
                              value 11;
                              description
                                "December";
                            }
                          }
                          must "../day-of-month";
                          description
                            "Month of the year";
                        }
    
                        leaf day-of-month {
                          type uint32 {
                            range "1..31";
                          }
                          description
                            "Day of the month";
                        }
    
                        leaf year {
                          type uint32 {
                            range "1993..2035";
                          }
                          must
                            "../month and ../day-of-month";
                          description "Year";
                        }
                      }  // container time-and-date
    
                      container pending {
                        presence
                          "Indicates a pending node is configured.";
                        description
                          "Keep operation in the pending state";
                      }  // container pending
    
                      container after {
                        presence
                          "Indicates a after node is configured.";
                        description
                          "Schedule operation after specified time";
                        container time {
                          description
                            "Time in hh:mm:ss format";
                          leaf hour {
                            type uint32 {
                              range "0..23";
                            }
                            mandatory true;
                            description
                              "Time in hh:mm:ss format";
                          }
    
                          leaf minute {
                            type uint32 {
                              range "0..59";
                            }
                            mandatory true;
                            description
                              "Time in hh:mm:ss format";
                          }
    
                          leaf second {
                            type uint32 {
                              range "0..59";
                            }
                            mandatory true;
                            description
                              "Time in hh:mm:ss format";
                          }
                        }  // container time
                      }  // container after
    
                      container now {
                        presence
                          "Indicates a now node is configured.";
                        description
                          "Schedule operation now";
                      }  // container now
                    }  // container start-time
                  }  // list monitor
                }  // container monitors
              }  // container schedule
    
              container reaction {
                description
                  "MPLSLM reaction configuration";
                container monitors {
                  description
                    "MPLSLM instance to be configured";
                  list monitor {
                    key "monitor-id";
                    description
                      "MPLSLM instance to be configured";
                    leaf monitor-id {
                      type uint32 {
                        range "1..2048";
                      }
                      description
                        "MPLSLM instance to be configured";
                    }
    
                    container react {
                      description
                        "Specify an element to be monitored for reaction";
                      container connection-loss {
                        presence
                          "Indicates a connection-loss node is configured.";
                        description
                          "Reaction on connection loss of monitored MPLSLM";
                        container action {
                          description
                            "Type of action to be taken on threshold violation(s)";
                          container logging {
                            presence
                              "Indicates a logging node is configured.";
                            description
                              "Generate a syslog alarm on threshold violation";
                          }  // container logging
    
                          container threshold {
                            description
                              "Configure threshold parameters on monitored element";
                            container type {
                              description
                                "Threshold type";
                              container immediate {
                                must
                                  "not(../consecutive)";
                                presence
                                  "Indicates a immediate node is configured.";
                                description
                                  "Take action immediately upon threshold violation";
                              }  // container immediate
    
                              leaf consecutive {
                                type uint32 {
                                  range "1..16";
                                }
                                must
                                  "not(../immediate)";
                                description
                                  "Take action after a number of consecutive violations";
                              }
                            }  // container type
                          }  // container threshold
                        }  // container action
                      }  // container connection-loss
    
                      container timeout {
                        presence
                          "Indicates a timeout node is configured.";
                        description
                          "Reaction on timeout of monitored MPLSLM";
                        container action {
                          description
                            "Type of action to be taken on threshold violation(s)";
                          container logging {
                            presence
                              "Indicates a logging node is configured.";
                            description
                              "Generate a syslog alarm on threshold violation";
                          }  // container logging
    
                          container threshold {
                            description
                              "Configure threshold parameters on monitored element";
                            container type {
                              description
                                "Threshold type";
                              container immediate {
                                must
                                  "not(../consecutive)";
                                presence
                                  "Indicates a immediate node is configured.";
                                description
                                  "Take action immediately upon threshold violation";
                              }  // container immediate
    
                              leaf consecutive {
                                type uint32 {
                                  range "1..16";
                                }
                                must
                                  "not(../immediate)";
                                description
                                  "Take action after a number of consecutive violations";
                              }
                            }  // container type
                          }  // container threshold
                        }  // container action
                      }  // container timeout
    
                      container lpd {
                        description
                          "Reaction on LPD violation";
                        container tree-trace {
                          presence
                            "Indicates a tree-trace node is configured.";
                          description
                            "Tree trace violation";
                          container action {
                            description
                              "Type of action to be taken on threshold violation(s)";
                            container logging {
                              presence
                                "Indicates a logging node is configured.";
                              description
                                "Generate a syslog alarm on threshold violation";
                            }  // container logging
    
                            container threshold {
                              description
                                "Configure threshold parameters on monitored element";
                              container type {
                                description
                                  "Threshold type";
                                container immediate {
                                  must
                                    "not(../consecutive)";
                                  presence
                                    "Indicates a immediate node is configured.";
                                  description
                                    "Take action immediately upon threshold violation";
                                }  // container immediate
    
                                leaf consecutive {
                                  type uint32 {
                                    range
                                      "1..16";
                                  }
                                  must
                                    "not(../immediate)";
                                  description
                                    "Take action after a number of consecutive violations";
                                }
                              }  // container type
                            }  // container threshold
                          }  // container action
                        }  // container tree-trace
    
                        container lpd-group {
                          presence
                            "Indicates a lpd-group node is configured.";
                          description
                            "LPD group violation";
                          container action {
                            description
                              "Type of action to be taken on threshold violation(s)";
                            container logging {
                              presence
                                "Indicates a logging node is configured.";
                              description
                                "Generate a syslog alarm on threshold violation";
                            }  // container logging
    
                            container threshold {
                              description
                                "Configure threshold parameters on monitored element";
                              container type {
                                description
                                  "Threshold type";
                                container immediate {
                                  must
                                    "not(../consecutive)";
                                  presence
                                    "Indicates a immediate node is configured.";
                                  description
                                    "Take action immediately upon threshold violation";
                                }  // container immediate
    
                                leaf consecutive {
                                  type uint32 {
                                    range
                                      "1..16";
                                  }
                                  must
                                    "not(../immediate)";
                                  description
                                    "Take action after a number of consecutive violations";
                                }
                              }  // container type
                            }  // container threshold
                          }  // container action
                        }  // container lpd-group
                      }  // container lpd
                    }  // container react
                  }  // list monitor
                }  // container monitors
              }  // container reaction
            }  // container lsp-monitor
    
            container discovery {
              description
                "PE discovery configuration";
              container vpn {
                description
                  "Layer 3 VPN PE discovery configuration";
                leaf interval {
                  type uint32 {
                    range "30..70560";
                  }
                  description
                    "Specify a discovery refresh interval";
                }
              }  // container vpn
            }  // container discovery
          }  // container mpls
    
          container server {
            description
              "IPSLA IPPM server configuration";
            container twamp {
              presence
                "Indicates a twamp node is configured.";
              description
                "IPSLA IPPM TWAMP server configuration";
              leaf port {
                type uint32 {
                  range "1..65535";
                }
                description "IPPM server port";
              }
    
              container timer {
                description
                  "IPPM server timer configurations";
                leaf inactivity {
                  type uint32 {
                    range "1..6000";
                  }
                  description
                    "IPPM server inactivity timer";
                }
              }  // container timer
            }  // container twamp
          }  // container server
        }  // container ipsla
      }  // module Cisco-IOS-XR-um-ipsla-cfg
    

© 2023 YumaWorks, Inc. All rights reserved.