submodule Cisco-IOS-XR-man-ipsla-oper-sub2 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-man-ipsla-oper {
        prefix Cisco-IOS-XR-man-ipsla-oper;
    }

    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR man-ipsla package operational data.
     
     Copyright (c) 2013-2019 by Cisco Systems, Inc.
     All rights reserved.";

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

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

    semver:module-version "1.0.0";

    typedef Op-type-enum {
      type enumeration {
        enum "icmp-echo" {
          value 1;
          description "icmp echo";
        }
        enum "icmp-path-jitter" {
          value 2;
          description "icmp path jitter";
        }
        enum "icmp-path-echo" {
          value 4;
          description "icmp path echo";
        }
        enum "udp-jitter" {
          value 8;
          description "udp jitter";
        }
        enum "udp-echo" {
          value 16;
          description "udp echo";
        }
        enum "mpls-lsp-ping" {
          value 32;
          description "mpls lsp ping";
        }
        enum "mpls-lsp-trace" {
          value 64;
          description "mpls lsp trace";
        }
        enum "mpls-lsp-group" {
          value 128;
          description "mpls lsp group";
        }
      }
      description "IPSLA Operation Types";
    }

    typedef Ipsla-ret-code {
      type enumeration {
        enum "ipsla-ret-code-unknown" {
          value 0;
          description
            "ipsla ret code unknown";
        }
        enum "ipsla-ret-code-ok" {
          value 1;
          description "ipsla ret code ok";
        }
        enum "ipsla-ret-code-disconnect" {
          value 2;
          description
            "ipsla ret code disconnect";
        }
        enum "ipsla-ret-code-over-threshold" {
          value 3;
          description
            "ipsla ret code over threshold";
        }
        enum "ipsla-ret-code-timeout" {
          value 4;
          description
            "ipsla ret code timeout";
        }
        enum "ipsla-ret-code-busy" {
          value 5;
          description "ipsla ret code busy";
        }
        enum "ipsla-ret-code-no-connection" {
          value 6;
          description
            "ipsla ret code no connection";
        }
        enum "ipsla-ret-code-dropped" {
          value 7;
          description
            "ipsla ret code dropped";
        }
        enum "ipsla-ret-code-sequence-error" {
          value 8;
          description
            "ipsla ret code sequence error";
        }
        enum "ipsla-ret-code-verify-error" {
          value 9;
          description
            "ipsla ret code verify error";
        }
        enum
          "ipsla-ret-code-application-specific" {
          value 10;
          description
            "ipsla ret code application specific";
        }
        enum
          "ipsla-ret-code-dns-server-timeout" {
          value 11;
          description
            "ipsla ret code dns server timeout";
        }
        enum
          "ipsla-ret-code-tcp-connect-timeout" {
          value 12;
          description
            "ipsla ret code tcp connect timeout";
        }
        enum
          "ipsla-ret-code-http-transaction-timeout" {
          value 13;
          description
            "ipsla ret code http transaction timeout";
        }
        enum
          "ipsla-ret-code-dns-query-error" {
          value 14;
          description
            "ipsla ret code dns query error";
        }
        enum "ipsla-ret-code-http-error" {
          value 15;
          description
            "ipsla ret code http error";
        }
        enum "ipsla-ret-code-internal-error" {
          value 16;
          description
            "ipsla ret code internal error";
        }
        enum
          "ipsla-ret-code-mpls-lsp-echo-tx-error" {
          value 17;
          description
            "ipsla ret code mpls lsp echo tx error";
        }
        enum
          "ipsla-ret-code-mpls-lsp-unreachable" {
          value 18;
          description
            "ipsla ret code mpls lsp unreachable";
        }
        enum
          "ipsla-ret-code-mpls-lsp-malformed-request" {
          value 19;
          description
            "ipsla ret code mpls lsp malformed request";
        }
        enum
          "ipsla-ret-code-mpls-lsp-reachable-but-not-fec" {
          value 20;
          description
            "ipsla ret code mpls lsp reachable but not fec";
        }
        enum
          "ipsla-ret-code-mpls-lsp-ds-map-mismatch" {
          value 21;
          description
            "ipsla ret code mpls lsp ds map mismatch";
        }
        enum
          "ipsla-ret-code-mpls-lsp-duplicate" {
          value 22;
          description
            "ipsla ret code mpls lsp duplicate";
        }
        enum "ipsla-ret-code-failure" {
          value 23;
          description
            "ipsla ret code failure";
        }
        enum "ipsla-ret-code-malloc-failure" {
          value 24;
          description
            "ipsla ret code malloc failure";
        }
        enum
          "ipsla-ret-code-sock-open-error" {
          value 25;
          description
            "ipsla ret code sock open error";
        }
        enum
          "ipsla-ret-code-sock-bind-error" {
          value 26;
          description
            "ipsla ret code sock bind error";
        }
        enum
          "ipsla-ret-code-sock-send-error" {
          value 27;
          description
            "ipsla ret code sock send error";
        }
        enum
          "ipsla-ret-code-sock-recv-error" {
          value 28;
          description
            "ipsla ret code sock recv error";
        }
        enum
          "ipsla-ret-code-sock-connect-error" {
          value 29;
          description
            "ipsla ret code sock connect error";
        }
        enum
          "ipsla-ret-code-sock-set-option-error" {
          value 30;
          description
            "ipsla ret code sock set option error";
        }
        enum
          "ipsla-ret-code-sock-attach-error" {
          value 31;
          description
            "ipsla ret code sock attach error";
        }
        enum "ipsla-ret-code-ctrl-msg-error" {
          value 32;
          description
            "ipsla ret code ctrl msg error";
        }
        enum "ipsla-ret-code-no-key-chain" {
          value 33;
          description
            "ipsla ret code no key chain";
        }
        enum
          "ipsla-ret-code-key-chain-lib-fail" {
          value 34;
          description
            "ipsla ret code key chain lib fail";
        }
        enum "ipsla-ret-code-no-key-id" {
          value 35;
          description
            "ipsla ret code no key id";
        }
        enum "ipsla-ret-code-invalid-key-id" {
          value 36;
          description
            "ipsla ret code invalid key id";
        }
        enum "ipsla-ret-code-entry-exist" {
          value 37;
          description
            "ipsla ret code entry exist";
        }
        enum
          "ipsla-ret-code-entry-not-found" {
          value 38;
          description
            "ipsla ret code entry not found";
        }
        enum "ipsla-ret-code-hop-over-max" {
          value 39;
          description
            "ipsla ret code hop over max";
        }
        enum
          "ipsla-ret-code-hop-dup-address" {
          value 40;
          description
            "ipsla ret code hop dup address";
        }
        enum "ipsla-ret-code-vrf-name-error" {
          value 41;
          description
            "ipsla ret code vrf name error";
        }
        enum "ipsla-ret-code-resp-failure" {
          value 42;
          description
            "ipsla ret code resp failure";
        }
        enum "ipsla-ret-code-auth-failure" {
          value 43;
          description
            "ipsla ret code auth failure";
        }
        enum "ipsla-ret-code-format-failure" {
          value 44;
          description
            "ipsla ret code format failure";
        }
        enum "ipsla-ret-code-port-in-use" {
          value 45;
          description
            "ipsla ret code port in use";
        }
        enum "ipsla-ret-code-no-route" {
          value 46;
          description
            "ipsla ret code no route";
        }
        enum "ipsla-ret-code-pending" {
          value 47;
          description
            "ipsla ret code pending";
        }
        enum
          "ipsla-ret-code-invalid-address" {
          value 48;
          description
            "ipsla ret code invalid address";
        }
        enum "ipsla-ret-code-max" {
          value 49;
          description "ipsla ret code max";
        }
      }
      description "Ipsla ret code";
    }

    typedef Ipsla-mpls-lpd-discovery-mode-enum {
      type enumeration {
        enum "ipsla-mpls-lpd-unknown" {
          value 0;
          description
            "ipsla mpls lpd unknown";
        }
        enum
          "ipsla-mpls-lpd-initial-running" {
          value 1;
          description
            "ipsla mpls lpd initial running";
        }
        enum
          "ipsla-mpls-lpd-initial-complete" {
          value 2;
          description
            "ipsla mpls lpd initial complete";
        }
        enum
          "ipsla-mpls-lpd-rediscovery-running" {
          value 3;
          description
            "ipsla mpls lpd rediscovery running";
        }
        enum
          "ipsla-mpls-lpd-rediscovery-complete" {
          value 4;
          description
            "ipsla mpls lpd rediscovery complete";
        }
      }
      description
        "Ipsla mpls lpd discovery mode enum";
    }

    typedef Ipsla-mpls-lpd-path-discovery-status {
      type enumeration {
        enum
          "ipsla-mpls-lpd-path-discovery-unknown" {
          value 0;
          description
            "ipsla mpls lpd path discovery unknown";
        }
        enum
          "ipsla-mpls-lpd-path-discovery-ok" {
          value 1;
          description
            "ipsla mpls lpd path discovery ok";
        }
        enum
          "ipsla-mpls-lpd-path-discovery-broken" {
          value 2;
          description
            "ipsla mpls lpd path discovery broken";
        }
        enum
          "ipsla-mpls-lpd-path-discovery-unexplorable" {
          value 3;
          description
            "ipsla mpls lpd path discovery unexplorable";
        }
      }
      description
        "Ipsla mpls lpd path discovery status";
    }

    typedef Ipsla-mpls-lpd-ret-code {
      type enumeration {
        enum
          "ipsla-mpls-lpd-ret-code-unknown" {
          value 1;
          description
            "ipsla mpls lpd ret code unknown";
        }
        enum
          "ipsla-mpls-lpd-ret-code-no-path" {
          value 2;
          description
            "ipsla mpls lpd ret code no path";
        }
        enum
          "ipsla-mpls-lpd-ret-code-all-path-broken" {
          value 3;
          description
            "ipsla mpls lpd ret code all path broken";
        }
        enum
          "ipsla-mpls-lpd-ret-code-all-path-unexplorable" {
          value 4;
          description
            "ipsla mpls lpd ret code all path unexplorable";
        }
        enum
          "ipsla-mpls-lpd-ret-code-all-path-broken-or-unexplorable" {
          value 5;
          description
            "ipsla mpls lpd ret code all path broken or
           unexplorable";
        }
        enum
          "ipsla-mpls-lpd-ret-code-timeout" {
          value 6;
          description
            "ipsla mpls lpd ret code timeout";
        }
        enum "ipsla-mpls-lpd-ret-code-error" {
          value 7;
          description
            "ipsla mpls lpd ret code error";
        }
        enum "ipsla-mpls-lpd-ret-code-ok" {
          value 8;
          description
            "ipsla mpls lpd ret code ok";
        }
      }
      description "Ipsla mpls lpd ret code";
    }

    typedef Ipv6addr {
      type inet:ipv6-address;
      description "Ipv6addr";
    }

    typedef Ipsla-target-type-enum {
      type enumeration {
        enum "ipv4-address-target-type" {
          value 1;
          description "IPv4 address";
        }
        enum "ipv4-prefix-target-type" {
          value 2;
          description "IPv4 prefix";
        }
        enum "tunnel-id-target-type" {
          value 3;
          description "Tunnel ID";
        }
        enum "ipv4-pseudowire-target-type" {
          value 4;
          description "IPv4 pseudowire";
        }
        enum "ipv6-address-target-type" {
          value 5;
          description "IPv6 address";
        }
      }
      description "IPSLA Target Types";
    }

    typedef Ipsla-oper-state-enum {
      type enumeration {
        enum "ipsla-oper-state-inactive" {
          value 0;
          description
            "ipsla oper state inactive";
        }
        enum "ipsla-oper-state-pending" {
          value 1;
          description
            "ipsla oper state pending";
        }
        enum "ipsla-oper-state-active" {
          value 2;
          description
            "ipsla oper state active";
        }
      }
      description "Ipsla oper state enum";
    }

    typedef Ipsla-mpls-add-delete-enum {
      type enumeration {
        enum "ipsla-mpls-add-delete-add-q" {
          value 1;
          description
            "ipsla mpls add delete add q";
        }
        enum
          "ipsla-mpls-add-delete-delete-q" {
          value 2;
          description
            "ipsla mpls add delete delete q";
        }
      }
      description
        "Ipsla mpls add delete enum";
    }

    typedef Ipsla-lsp-grp-path-status-enum {
      type enumeration {
        enum
          "ipsla-lsp-grp-path-status-unknown" {
          value 0;
          description
            "ipsla lsp grp path status unknown";
        }
        enum "ipsla-lsp-grp-path-status-up" {
          value 1;
          description
            "ipsla lsp grp path status up";
        }
        enum
          "ipsla-lsp-grp-path-status-down" {
          value 2;
          description
            "ipsla lsp grp path status down";
        }
        enum
          "ipsla-lsp-grp-path-status-retry" {
          value 3;
          description
            "ipsla lsp grp path status retry";
        }
        enum
          "ipsla-lsp-grp-path-status-pending" {
          value 4;
          description
            "ipsla lsp grp path status pending";
        }
      }
      description
        "Ipsla lsp grp path status enum";
    }

    typedef Ipsla-lsp-grp-status-enum {
      type enumeration {
        enum "ipsla-lsp-grp-status-unknown" {
          value 1;
          description
            "ipsla lsp grp status unknown";
        }
        enum "ipsla-lsp-grp-status-up" {
          value 2;
          description
            "ipsla lsp grp status up";
        }
        enum "ipsla-lsp-grp-status-partial" {
          value 3;
          description
            "ipsla lsp grp status partial";
        }
        enum "ipsla-lsp-grp-status-down" {
          value 4;
          description
            "ipsla lsp grp status down";
        }
        enum "ipsla-lsp-grp-status-pending" {
          value 5;
          description
            "ipsla lsp grp status pending";
        }
      }
      description
        "Ipsla lsp grp status enum";
    }

    grouping IPSLA-LPD-PATH-STATS-BAG {
      description
        "IPSLA LPD Path Statistics";
      container path-id {
        description "LPD path identifier";
        uses IPSLA-LPD-PATH-ID-BAG;
      }  // container path-id

      leaf return-code {
        type Ipsla-ret-code;
        description "Path return code";
      }
    }  // grouping IPSLA-LPD-PATH-STATS-BAG

    grouping IPSLA-UDP-JITTER-SPEC-STATS-BAG {
      description
        "UDP Jitter Specific Statistics";
      leaf jitter-in {
        type uint32;
        description
          "Input Jitter moving average, computed as per
         RFC1889";
      }

      leaf jitter-out {
        type uint32;
        description
          "Output Jitter moving average, computed as per
         RFC1889";
      }

      leaf packet-loss-sd {
        type uint32;
        description
          "Packets lost in source to destination (SD)
         direction";
      }

      leaf packet-loss-ds {
        type uint32;
        description
          "Packets lost in destination to source (DS)
         direction";
      }

      leaf packet-out-of-sequence {
        type uint32;
        description
          "Packets out of sequence";
      }

      leaf packet-mia {
        type uint32;
        description
          "Packets missing in action (cannot determine if
         theywere lost in SD or DS direction";
      }

      leaf packet-skipped {
        type uint32;
        description
          "Packets which are skipped";
      }

      leaf packet-late-arrivals {
        type uint32;
        description "Packets arriving late";
      }

      leaf packet-invalid-tstamp {
        type uint32;
        description
          "Packets with bad timestamps";
      }

      leaf internal-errors-count {
        type uint32;
        description
          "Number of internal errors";
      }

      leaf busies-count {
        type uint32;
        description "Number of busies";
      }

      leaf positive-sd-sum {
        type uint32;
        units "millisecond";
        description
          "Sum of positive jitter values (i.e., network
         latency increases for two consecutive  packets)
         in SD direction Measured  in milliseconds";
      }

      leaf positive-sd-sum2 {
        type uint64;
        description
          "Sum of squares of positive jitter values in SD
         direction";
      }

      leaf positive-sd-min {
        type uint32;
        description
          "Minimum of positive jitter values in SD
         direction";
      }

      leaf positive-sd-max {
        type uint32;
        description
          "Maximum of positive jitter values in SD
         direction";
      }

      leaf positive-sd-count {
        type uint32;
        description
          "Number of positive jitter values in SD direction";
      }

      leaf negative-sd-sum {
        type uint32;
        units "millisecond";
        description
          "Sum of negative jitter values (i.e., network
         latency decreases for two consecutive packets)
         in SD direction Measured  in milliseconds";
      }

      leaf negative-sd-sum2 {
        type uint64;
        description
          "Sum of squares of negative jitter values in SD
         direction";
      }

      leaf negative-sd-min {
        type uint32;
        description
          "Minimum of negative jitter values in SD
         direction";
      }

      leaf negative-sd-max {
        type uint32;
        description
          "Maximum of negative jitter values in SD
         direction";
      }

      leaf negative-sd-count {
        type uint32;
        description
          "Number of negative jitter values in SD direction";
      }

      leaf positive-ds-sum {
        type uint32;
        units "millisecond";
        description
          "Sum of positive jitter values (i.e., network
         latency increases for two consecutive packets)
         in DS direction Measured  in milliseconds";
      }

      leaf positive-ds-sum2 {
        type uint64;
        description
          "Sum of squares of positive jitter values in DS
         direction";
      }

      leaf positive-ds-min {
        type uint32;
        description
          "Minimum of positive jitter values in DS
         direction";
      }

      leaf positive-ds-max {
        type uint32;
        description
          "Maximum of positive jitter values in DS
         direction";
      }

      leaf positive-ds-count {
        type uint32;
        description
          "Number of positive jitter values in DS direction";
      }

      leaf negative-ds-sum {
        type uint32;
        units "millisecond";
        description
          "Sum of negative jitter values (i.e., network
         latency decreases for two consecutive packets)
         in DS direction Measured  in milliseconds";
      }

      leaf negative-ds-sum2 {
        type uint64;
        description
          "Sum of squares of negative jitter values in DS
         direction";
      }

      leaf negative-ds-min {
        type uint32;
        description
          "Minimum of negative jitter values in DS
         direction";
      }

      leaf negative-ds-max {
        type uint32;
        description
          "Maximum of negative jitter values in DS
         direction";
      }

      leaf negative-ds-count {
        type uint32;
        description
          "Number of negative jitter values in DS direction";
      }

      leaf one-way-count {
        type uint32;
        description
          "Number of probe/probe-response pairs used to
         compute one-way statistics";
      }

      leaf one-way-sd-min {
        type uint32;
        description
          "Minimum of one-way jitter values in SD direction
         (msec)";
      }

      leaf one-way-sd-max {
        type uint32;
        description
          "Maximum of one-way jitter values in SD direction
         (msec)";
      }

      leaf one-way-sd-sum {
        type uint32;
        description
          "Sum of one-way jitter values in SD direction
         (msec)";
      }

      leaf one-way-sd-sum2 {
        type uint64;
        description
          "Sum of squares of one-way jitter values in SD
         direction (msec)";
      }

      leaf one-way-ds-min {
        type uint32;
        description
          "Minimum of one-way jitter values in DS direction
         (msec)";
      }

      leaf one-way-ds-max {
        type uint32;
        description
          "Maximum of one-way jitter values in DS direction
         (msec)";
      }

      leaf one-way-ds-sum {
        type uint32;
        description
          "Sum of one-way jitter values in DS direction
         (msec)";
      }

      leaf one-way-ds-sum2 {
        type uint64;
        description
          "Sum of squares of the OneWayMinDS and
         OneWayMaxDS values (msec)";
      }
    }  // grouping IPSLA-UDP-JITTER-SPEC-STATS-BAG

    grouping IPSLA-ICMP-PATH-JITTER-SPEC-STATS-BAG {
      description
        "ICMP Path Jitter Statistics for a Hop";
      leaf source-address {
        type inet:ipv4-address;
        description
          "IP Address of the source";
      }

      leaf dest-address {
        type inet:ipv4-address;
        description
          "IP Address of the destination";
      }

      leaf hop-address {
        type inet:ipv4-address;
        description
          "IP address of the hop in the path";
      }

      leaf packet-interval {
        type uint32;
        description
          "Interval between echos in ms";
      }

      leaf response-time-count {
        type uint32;
        description
          "Number of RTT samples  used for the statistics";
      }

      leaf response-time {
        type uint32;
        description "RTT";
      }

      leaf min-response-time {
        type uint32;
        description "Minimum RTT";
      }

      leaf max-response-time {
        type uint32;
        description "Maximum RTT";
      }

      leaf sum-response-time {
        type uint32;
        description "Sum of RTT";
      }

      leaf sum2-response-time {
        type uint64;
        description "Sum of RTT^2";
      }

      leaf packet-count {
        type uint32;
        description
          "Number of Echo replies received ";
      }

      leaf packet-loss-count {
        type uint32;
        description "Number of packets lost";
      }

      leaf out-of-sequence-count {
        type uint32;
        description
          "Number of out of sequence packets";
      }

      leaf discarded-sample-count {
        type uint32;
        description
          "Number of discarded samples";
      }

      leaf verify-errors-count {
        type uint32;
        description
          "Number of packets with data corruption";
      }

      leaf dropped-error-count {
        type uint32;
        description
          "Number of packets dropped";
      }

      leaf jitter {
        type uint32;
        description
          "Jitter value for this node in the path";
      }

      leaf pos-jitter-sum {
        type uint32;
        description
          "Sum of positive jitter value";
      }

      leaf pos-jitter-sum2 {
        type uint64;
        description
          "Sum of squares of positive jitter values";
      }

      leaf pos-jitter-min {
        type uint32;
        description
          "Minimum positive jitter value";
      }

      leaf pos-jitter-max {
        type uint32;
        description
          "Maximum positive jitter value";
      }

      leaf pos-jitter-count {
        type uint32;
        description
          "Number of positive jitter values";
      }

      leaf neg-jitter-sum {
        type uint32;
        description
          "Sum of negative jitter values";
      }

      leaf neg-jitter-min {
        type uint32;
        description
          "Minimum negative jitter value";
      }

      leaf neg-jitter-max {
        type uint32;
        description
          "Maximum negative jitter value";
      }

      leaf neg-jitter-sum2 {
        type uint64;
        description
          "Sum of squares of negative jitter values";
      }

      leaf neg-jitter-count {
        type uint32;
        description
          "Number of negative jitter values";
      }
    }  // grouping IPSLA-ICMP-PATH-JITTER-SPEC-STATS-BAG

    grouping IPSLA-UNION-STATS-BAG {
      description "IPSLA UNION STATS BAG";
      container icmp-path-jitter-stats {
        when
          "../op-type = 'icmp-path-jitter'" {
          description
            "../op_type = 'ICMPPathJitter'";
        }
        description "icmp path jitter stats";
        uses IPSLA-ICMP-PATH-JITTER-SPEC-STATS-BAG;
      }  // container icmp-path-jitter-stats

      container udp-jitter-stats {
        when "../op-type = 'udp-jitter'" {
          description
            "../op_type = 'UDPJitter'";
        }
        description "udp jitter stats";
        uses IPSLA-UDP-JITTER-SPEC-STATS-BAG;
      }  // container udp-jitter-stats

      leaf op-type {
        type Op-type-enum;
        description "op type";
      }
    }  // grouping IPSLA-UNION-STATS-BAG

    grouping IPSLA-COMMON-STATS-BAG {
      description "IPSLA Common Stats";
      leaf operation-time {
        type uint64;
        description "Operation Time";
      }

      leaf return-code {
        type Ipsla-ret-code;
        description "Return code";
      }

      leaf response-time-count {
        type uint32;
        description
          "Number of RTT samples used for the statistics";
      }

      leaf response-time {
        type uint32;
        description "RTT";
      }

      leaf min-response-time {
        type uint32;
        description "Minimum RTT";
      }

      leaf max-response-time {
        type uint32;
        description "Maximum RTT";
      }

      leaf sum-response-time {
        type uint32;
        description "Sum of RTT";
      }

      leaf sum2-response-time {
        type uint64;
        description "Sum of RTT^2";
      }

      leaf update-count {
        type uint32;
        description
          "Number of updates processed";
      }

      leaf ok-count {
        type uint32;
        description
          "Number of updates with Okay return code";
      }

      leaf disconnect-count {
        type uint32;
        description
          "Number of updates with Disconnected return code";
      }

      leaf timeout-count {
        type uint32;
        description
          "Number of updates with Timeout return code";
      }

      leaf busy-count {
        type uint32;
        description
          "Number of updates with Busy return code";
      }

      leaf no-connection-count {
        type uint32;
        description
          "Number of updates with NotConnected return code";
      }

      leaf dropped-count {
        type uint32;
        description
          "Number of updates with Dropped return code";
      }

      leaf internal-error-count {
        type uint32;
        description
          "Number of updates with InternalError return code";
      }

      leaf sequence-error-count {
        type uint32;
        description
          "Number of updates with SeqError return code";
      }

      leaf verify-error-count {
        type uint32;
        description
          "Number of updates with VerifyError return code";
      }
    }  // grouping IPSLA-COMMON-STATS-BAG

    grouping IPSLA-GLOBAL-STATS-BAG {
      description "Global Statistics Bag";
      container common-stats {
        description "Common Stats";
        uses IPSLA-COMMON-STATS-BAG;
      }  // container common-stats

      container specific-stats {
        description
          "Operation Specific Stats";
        uses IPSLA-UNION-STATS-BAG;
      }  // container specific-stats
    }  // grouping IPSLA-GLOBAL-STATS-BAG

    grouping IPSLA-HISTORY-BAG {
      description "IP SLA history data bag";
      container target-address {
        description
          "Target for the operation";
        uses IPSLA-TARGET-UNION;
      }  // container target-address

      leaf start-time {
        type uint64;
        description
          "Sample Start Time expressed in msec since00:00
         :00 UTC, January 1, 1970";
      }

      leaf response-time {
        type uint32;
        units "millisecond";
        description
          "Round Trip Time (milliseconds)";
      }

      leaf return-code {
        type Ipsla-ret-code;
        description "Response Return Code";
      }
    }  // grouping IPSLA-HISTORY-BAG

    grouping IPSLA-LPD-STATE-BAG {
      description "IPSLA LPD State";
      container target-address {
        description "Target for LPD";
        uses IPSLA-TARGET-UNION;
      }  // container target-address

      leaf monitor-id {
        type uint32;
        description "MPLSLM monitor ID";
      }

      leaf discovery-mode {
        type Ipsla-mpls-lpd-discovery-mode-enum;
        description "Latest LPD mode";
      }

      leaf start-time {
        type uint64;
        description "Latest start time";
      }

      leaf return-code {
        type Ipsla-mpls-lpd-ret-code;
        description "Latest return code";
      }

      leaf completion-time {
        type uint32;
        description "Latest completion time";
      }

      leaf path-count {
        type uint32;
        description
          "Number of discovered paths";
      }
    }  // grouping IPSLA-LPD-STATE-BAG

    grouping IPSLA-LPD-PATH-STATE-BAG {
      description "IPSLA LPD Path State";
      container path-id {
        description "LPD path identifier";
        uses IPSLA-LPD-PATH-ID-BAG;
      }  // container path-id

      leaf path-status {
        type Ipsla-mpls-lpd-path-discovery-status;
        description "Path status";
      }
    }  // grouping IPSLA-LPD-PATH-STATE-BAG

    grouping IPSLA-IPV4-PW {
      description
        "IPSLA IPv4 Pseudowire Target";
      leaf address {
        type inet:ipv4-address;
        description "IPv4 address";
      }

      leaf virtual-circuit-id {
        type uint32;
        description "Virtual circuit ID";
      }
    }  // grouping IPSLA-IPV4-PW

    grouping IPSLA-TUNNEL-ID {
      description "IPSLA Tunnel ID Target";
      leaf tunnel-id {
        type uint32;
        description "Tunnel ID";
      }
    }  // grouping IPSLA-TUNNEL-ID

    grouping IPSLA-IPV4-PREFIX {
      description "IPSLA IPv4 Prefix Target";
      leaf address {
        type inet:ipv4-address;
        description "IPv4 address";
      }

      leaf mask-length {
        type uint8;
        description "Mask length";
      }
    }  // grouping IPSLA-IPV4-PREFIX

    grouping IPSLA-TARGET-UNION {
      description "IPSLA TARGET UNION";
      container ipv4-prefix-target {
        when
          "../target-type = 'ipv4-prefix-target-type'" {
          description
            "../TargetType = 'IPv4PrefixTargetType'";
        }
        description "IPv4 prefix target";
        uses IPSLA-IPV4-PREFIX;
      }  // container ipv4-prefix-target

      container tunnel-id-target {
        when
          "../target-type = 'tunnel-id-target-type'" {
          description
            "../TargetType = 'TunnelIDTargetType'";
        }
        description "Tunnel ID target";
        uses IPSLA-TUNNEL-ID;
      }  // container tunnel-id-target

      container ipv4-pseudowire-target {
        when
          "../target-type = 'ipv4-pseudowire-target-type'" {
          description
            "../TargetType = 'IPv4PseudowireTargetType'";
        }
        description "IPv4 pseudowire target";
        uses IPSLA-IPV4-PW;
      }  // container ipv4-pseudowire-target

      leaf target-type {
        type Ipsla-target-type-enum;
        description "TargetType";
      }

      leaf ipv4-address-target {
        when
          "../target-type = 'ipv4-address-target-type'" {
          description
            "../TargetType = 'IPv4AddressTargetType'";
        }
        type inet:ipv4-address;
        description "IPv4 address target";
      }

      leaf ipv6-address-target {
        when
          "../target-type = 'ipv6-address-target-type'" {
          description
            "../TargetType = 'IPv6AddressTargetType'";
        }
        type Ipv6addr;
        description "IPv6 address target";
      }
    }  // grouping IPSLA-TARGET-UNION

    grouping IPSLA-LPD-STATS-BAG {
      description "IPSLA LPD Statistics";
      container target-address {
        description "LPD target";
        uses IPSLA-TARGET-UNION;
      }  // container target-address

      leaf start-time {
        type uint64;
        description "LPD start time";
      }

      leaf return-code {
        type Ipsla-mpls-lpd-ret-code;
        description "LPD return code";
      }

      leaf completion-time-count {
        type uint32;
        description
          "Number of CompT samples";
      }

      leaf completion-time {
        type uint32;
        description "LPD Completion time";
      }

      leaf min-completion-time {
        type uint32;
        description "Minimum CompT";
      }

      leaf max-completion-time {
        type uint32;
        description "Maximum CompT";
      }

      leaf sum-completion-time {
        type uint32;
        description "Sum of CompT";
      }

      leaf path-count {
        type uint32;
        description "Number of paths";
      }

      leaf min-path-count {
        type uint32;
        description
          "Minimum number of paths";
      }

      leaf max-path-count {
        type uint32;
        description
          "Maximum number of paths";
      }

      leaf ok-count {
        type uint32;
        description "Number of successes";
      }

      leaf no-path-count {
        type uint32;
        description
          "Number of failures due to no path";
      }

      leaf all-paths-broken-count {
        type uint32;
        description
          "Number of failures due to all paths broken";
      }

      leaf all-paths-unexplorable-count {
        type uint32;
        description
          "Number of failures due to all paths unexplorable";
      }

      leaf all-paths-broken-or-unexplorable-count {
        type uint32;
        description
          "Number of failures due to all paths broken or
         unexplorable";
      }

      leaf timeout-count {
        type uint32;
        description
          "Number of failures due to timeout";
      }

      leaf internal-error-count {
        type uint32;
        description
          "Number of failures due to internal error";
      }

      leaf unknown-count {
        type uint32;
        description
          "Number of failures due to unknown cause";
      }
    }  // grouping IPSLA-LPD-STATS-BAG

    grouping IPSLA-OPER-STATE-BAG {
      description "IPSLA Operation State";
      leaf modification-time {
        type uint64;
        description
          "Last modification time of the operation
         expressed in msec since 00:00:00 UTC, January 1,
         1970";
      }

      leaf start-time {
        type uint64;
        description
          "Last start time of the operation expressedin
         msec since 00:00:00 UTC, January 1, 1970";
      }

      leaf attempt-count {
        type uint32;
        description
          "Number of data collection attempts";
      }

      leaf skipped-count {
        type uint32;
        description
          "Number of data collection cycles skipped";
      }

      leaf life-remaining {
        type uint32;
        units "second";
        description
          "Number of seconds left in current life";
      }

      leaf frequency {
        type uint32;
        description
          "Number of configured frequency Default 60 ";
      }

      leaf recurring {
        type boolean;
        description
          "For recurring operation configured";
      }

      leaf operational-state {
        type Ipsla-oper-state-enum;
        description "Operational state";
      }

      leaf flags {
        type uint32;
        description "Internal flags";
      }

      leaf local-port {
        type uint16;
        description "Cached local port";
      }

      leaf unexpected-packets {
        type uint32;
        description
          "Unexpected probe pkts punted from LPTS";
      }

      leaf unexpected-control-packets {
        type uint32;
        description
          "Unexpected control pkts puntedfrom LPTS";
      }

      leaf operation-time {
        type uint64;
        description
          "Start time of current instance of the operation";
      }
    }  // grouping IPSLA-OPER-STATE-BAG

    grouping IPSLA-DISCOVERY-PREFIX-BAG {
      description
        "IPSLA MPLS PE Discovery Prefix";
      leaf target-address {
        type inet:ipv4-address;
        description "PE target address";
      }

      leaf target-mask {
        type uint32;
        description "PE target mask length";
      }
    }  // grouping IPSLA-DISCOVERY-PREFIX-BAG

    grouping IPSLA-DISCOVERY-VRF-BAG {
      description
        "IPSLA MPLS PE Discovery VRF";
      leaf prefix-count {
        type uint32;
        description
          "Number of prefixes in VRF";
      }
    }  // grouping IPSLA-DISCOVERY-VRF-BAG

    grouping IPSLA-DISCOVERY-STATE-BAG {
      description
        "IPSLA MPLS PE Discovery State";
      leaf refresh-remaining {
        type uint32;
        units "second";
        description
          "Number of seconds left before next refresh";
      }
    }  // grouping IPSLA-DISCOVERY-STATE-BAG

    grouping IPSLA-MPLSLM-SCAN-QUEUE-BAG {
      description
        "IPSLA MPLSLM Scan Queue Entry";
      leaf target-address {
        type inet:ipv4-address;
        description "PE target address";
      }

      leaf target-mask {
        type uint32;
        description "PE target mask length";
      }

      leaf entry {
        type Ipsla-mpls-add-delete-enum;
        description
          "PE addition or deletion";
      }
    }  // grouping IPSLA-MPLSLM-SCAN-QUEUE-BAG

    grouping IPSLA-LPD-PATH-ID-BAG {
      description
        "IPSLA LPD Path Identifier";
      leaf lsp-selector {
        type inet:ipv4-address;
        description "LSP selector";
      }

      leaf output-interface {
        type xr:Interface-name;
        description "Output interface";
      }

      leaf nexthop-address {
        type inet:ipv4-address;
        description "Nexthop address";
      }

      leaf-list downstream-label {
        type uint32;
        max-elements 10;
        description
          "Downstream label stacks";
      }
    }  // grouping IPSLA-LPD-PATH-ID-BAG

    grouping IPSLA-MPLSLM-OP-PATH-STATE-BAG {
      description
        "IPSLA MPLSLM Operation Path State";
      container path-id {
        description "LPD path identifier";
        uses IPSLA-LPD-PATH-ID-BAG;
      }  // container path-id

      leaf path-status {
        type Ipsla-lsp-grp-path-status-enum;
        description "Latest path status";
      }

      leaf operation-time {
        type uint64;
        description "Latest operation time";
      }

      leaf response-time {
        type uint32;
        description "Latest RTT";
      }

      leaf success-count {
        type uint32;
        description
          "Number of path successes";
      }

      leaf failure-count {
        type uint32;
        description
          "Number of path failures";
      }
    }  // grouping IPSLA-MPLSLM-OP-PATH-STATE-BAG

    grouping IPSLA-MPLSLM-OP-STATE-BAG {
      description
        "IPSLA MPLSLM Operation State";
      leaf target-address {
        type inet:ipv4-address;
        description "PE target address";
      }

      leaf target-mask {
        type uint32;
        description "PE target mask length";
      }

      leaf group-status {
        type Ipsla-lsp-grp-status-enum;
        description
          "Latest LSP group status";
      }

      leaf operation-time {
        type uint64;
        description "Latest operation time";
      }
    }  // grouping IPSLA-MPLSLM-OP-STATE-BAG

    grouping IPSLA-MPLSLM-STATE-BAG {
      description "IPSLA MPLSLM State";
      leaf scan-remaining {
        type uint32;
        units "second";
        description
          "Number of seconds left before next scan for
         addition (0xffffffff means the timer is not
         running)";
      }

      leaf delete-scan-remaining {
        type uint32;
        units "second";
        description
          "Number of seconds left before next scan for
         deletion  (0xffffffff means the timer is not
         running)";
      }

      leaf rediscovery-remaining {
        type uint32;
        units "second";
        description
          "Number of seconds left before next path
         discovery (0xffffffff means the timer is not
         running)";
      }

      leaf lpd-compeletion-time {
        type uint32;
        units "second";
        description
          "LPD completion time (seconds) for the entire set
         of PEs which are discovered in this MPLSLM
         instance (0xffffffff means LPD is never
         completed yet)";
      }
    }  // grouping IPSLA-MPLSLM-STATE-BAG
  }  // submodule Cisco-IOS-XR-man-ipsla-oper-sub2