submodule Cisco-IOS-XR-perf-meas-oper-sub2 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-perf-meas-oper {
        prefix Cisco-IOS-XR-perf-meas-oper;
    }

    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    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 perf-meas package operational data.
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-06-02" {
      description
        "Added session id to endpoint liveness bag.
       2021-04-17
         Removed liveness parameters from delay profile bag.
       2021-02-26
         Remove PM hidden show cli, loss, history packet.
       2021-02-16
         Remove liveness history and liveness detection verbose from sr-policy delay schema.
       2021-01-08
         Added srpolicy liveness schema.
       2021-01-08
         Added srpolicy liveness history schema and renamed liveness detection schema.
       2020-12-19
         Added schema for endpoint liveness profile.
       2020-12-02
         Add sr-policy liveness profile bag and oper schema.
       2020-11-26
         Update endpoint show command bags in order to support liveness-detection.
       2020-11-17
         Added new bag for PPS info. IosSetYangSchemaRev Cisco-IOS-XR-perf-meas-oper
       2020-10-27
         Added anomaly support for sr-policy min delay metrics.
       2020-10-27
         Added all endpoint show commands support and respective bags.
       2020-10-15
         Update probe running reason name for link down.
       2020-10-02
         Added anomaly support for interface min delay metrics.
       2020-08-06
         Added liveness session state history information.
       2020-07-23
         Fixed typos in perf-meas oper bag.";
    }

    revision "2020-06-24" {
      description
        "Update perf-meas oper schema task group.
       2020-04-10
       Added new TX error counter for next hop MAC missing.
       2020-03-31
       721 nohelp CLI for liveness, loopback, endpoint, src-port, named profile, distribution.
       2020-03-25
       Add trace id in PM session bag.
       2020-03-17
       Added new types counters to count different types of PM DM sessions.
       2020-03-09
       Added new types of probe running errors and counters for probe running errors.
       2020-02-24
       Modifid type of service knobs from array to integer.
       2020-02-21
       Modify router alert type
       2020-02-19
       Modifiy periodic minimum change value.
       2020-02-13
       Modifiy delay-measurement hisotry key words.
       2020-01-22
       Added a new advertisement reason for interface delay-measurement.
       2019-12-16
       Revision IOS XR 7.2.1 Added responder src address and num of hops for PM DM.
       2019-12-09
       Added new reason for DM probe not running.
       2019-11-18
       Revision IOS XR 7.2.1 Added EDT for Liveness state for SR Policy Candidate path atmoic path.";
    }

    revision "2019-10-19" {
      description
        "Added burst-interval-effective to oper data.";
    }

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

    revision "2018-12-13" {
      description
        "Revision IOS XR 7.0.1 Added delay measurment for SR Policy and RSVP-TE LSP.";
    }

    revision "2017-10-17" {
      description "Revision Zero.";
    }

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

    semver:module-version "4.0.0";
    semver:module-version "3.0.0";
    semver:module-version "2.0.0";
    semver:module-version "1.0.0";

    typedef Pm-rl-pps-pool {
      type enumeration {
        enum "single-pps-pool" {
          value 0;
          description "Single PPS Pool";
        }
        enum "multiple-pps-pool" {
          value 1;
          description "Multiple PPS Pool";
        }
      }
      description "PM PPS Pool Type";
    }

    typedef Pm-payload {
      type enumeration {
        enum "payload-type-pm-dm" {
          value 0;
          description "Payload type PM DM";
        }
        enum "payload-type-twamp-test" {
          value 1;
          description
            "Payload type TWAMP test";
        }
        enum "payload-type-pm-lm" {
          value 2;
          description "Payload type PM LM";
        }
      }
      description "PM Payload Type";
    }

    typedef Pm-encap-mode {
      type enumeration {
        enum "encap-mode-mpls" {
          value 0;
          description "Encap-mode MPLS";
        }
        enum "encap-mode-udp" {
          value 1;
          description "Encap-mode UDP";
        }
      }
      description "PM Packet Encapsulation";
    }

    typedef Pm-delay-mode {
      type enumeration {
        enum "delay-mode-one-way" {
          value 0;
          description
            "One-way delay-measurement mode";
        }
        enum "delay-mode-two-way" {
          value 1;
          description
            "Two-way delay-measurement mode";
        }
        enum "delay-mode-loopback" {
          value 2;
          description
            "Loopback delay-measurement mode";
        }
      }
      description "PM Delay Mode Type";
    }

    typedef Pm-measurement {
      type enumeration {
        enum "delay-measurement-type" {
          value 0;
          description
            "Delay Measurement Type";
        }
        enum "loss-measurement-type" {
          value 1;
          description
            "Loss Measurement Type";
        }
        enum "liveness-detection-type" {
          value 2;
          description
            "Liveness Detection Type";
        }
      }
      description "PM Measurement Type";
    }

    typedef Pm-transport {
      type enumeration {
        enum "interface-transport-type" {
          value 0;
          description
            "Transport type for interface";
        }
        enum "rsvp-te-transport-type" {
          value 1;
          description
            "Transport type for RSVP-TE LSP";
        }
        enum "sr-policy-transport-type" {
          value 2;
          description
            "Transport type for SR Policy";
        }
        enum "endpoiont-transport-type" {
          value 3;
          description
            "Transport type for endpoint";
        }
      }
      description "PM Transport Type";
    }

    typedef Pm-history {
      type enumeration {
        enum "history-type-probe" {
          value 0;
          description
            "History type for delay measurement probe info";
        }
        enum "history-type-packet" {
          value 1;
          description
            "History type for delay measurement packet info";
        }
        enum "history-type-aggregated" {
          value 2;
          description
            "History type for delay measurement aggregated
           info";
        }
        enum "history-type-advertisement" {
          value 3;
          description
            "History type for delay measurement
           advertisement info";
        }
        enum "history-type-liveness-state" {
          value 4;
          description
            "History type for liveness state change info";
        }
        enum "history-type-lm-probe" {
          value 5;
          description
            "History type for loss measurement probe info";
        }
        enum "history-type-lm-packet" {
          value 6;
          description
            "History type for loss measurement aggregation
           info";
        }
        enum "history-type-lm-aggregated" {
          value 7;
          description
            "History type for loss measurement advertisement
           info";
        }
        enum "history-type-lm-advertisement" {
          value 8;
          description
            "History type for loss measurement advertisement
           info";
        }
      }
      description "PM history types";
    }

    typedef Pm-probe-running-error-reason {
      type enumeration {
        enum "probe-is-running" {
          value 0;
          description
            "Probe is running without error";
        }
        enum "platform-not-supported" {
          value 1;
          description
            "Measurement is not supported on this plaftorm";
        }
        enum "nonv1-active-node" {
          value 2;
          description
            "Node is not V1 active";
        }
        enum "control-code-error" {
          value 3;
          description
            "An uncleared control code error was received";
        }
        enum "interface-admin-down" {
          value 4;
          description "Interface admin down";
        }
        enum "mpls-capability-not-present" {
          value 5;
          description
            "MPLS is not enabled on interface";
        }
        enum "interface-not-present" {
          value 6;
          description
            "Interface not present or preconfigured";
        }
        enum "ip-address-not-configured" {
          value 7;
          description
            "IP address is not present on interface";
        }
        enum "next-hop-not-configured" {
          value 8;
          description
            "Nexthop address not configured.";
        }
        enum
          "wrong-next-hop-ip-address-type" {
          value 9;
          description
            "Wrong nexthop address type configured";
        }
        enum "protocol-port-not-configured" {
          value 10;
          description
            "Protocol querier destination port missing";
        }
        enum "protocol-port-failed-to-open" {
          value 11;
          description
            "Protocol querier destination port failed to
           open";
        }
        enum
          "high-total-interface-packets-per-second" {
          value 12;
          description
            "Total interface delay packets per second
           exceeds 80% of the total maximum packets per
           second allowed";
        }
        enum
          "client-end-of-data-not-received" {
          value 13;
          description
            "Client end of data message has not been
           received";
        }
        enum "missing-reverse-path" {
          value 14;
          description
            "Missing reverse path for loopback measurement
           mode";
        }
        enum "process-not-in-run-state" {
          value 15;
          description
            "Process is not in run state";
        }
        enum "session-suspended" {
          value 16;
          description
            "Measurement has been suspended by user using
           exec command";
        }
        enum "profile-not-configured" {
          value 17;
          description
            "Profile is not configured";
        }
        enum "missing-source-address" {
          value 18;
          description
            "Endpoint source address is missing";
        }
        enum "interface-type-not-supported" {
          value 19;
          description
            "Delay measurement is not supported for this
           interface type";
        }
        enum "interface-non-default-vrf" {
          value 20;
          description
            "Interface is not in default VRF";
        }
        enum "interface-down" {
          value 21;
          description "Interface down";
        }
        enum "invalid-vrf" {
          value 22;
          description
            "unable to resolve (non-existing) VRF";
        }
        enum "invalid-source-address" {
          value 23;
          description
            "Endpoint source address is invalid - cannot be
           same as endpoint destination";
        }
        enum "invalid-seg-list" {
          value 24;
          description
            "Segment list is invalid or not created";
        }
        enum "invalid-seg-list-version" {
          value 25;
          description
            "Segment list data is outdated";
        }
        enum "interface-ipv4-protocol-down" {
          value 26;
          description
            "IPv4 protocol is down for this interface";
        }
        enum "interface-ipv6-protocol-down" {
          value 27;
          description
            "IPv6 protocol is down for this interface";
        }
        enum "interface-ip-protocol-down" {
          value 28;
          description
            "Both IPv4 protocol and IPv6 protocol are down
           for this interface";
        }
        enum
          "interface-next-hop-mac-missing" {
          value 29;
          description
            "Next hop MAC address missing";
        }
        enum "ep-loopback-without-seglist" {
          value 30;
          description
            "Endpoint Loopback mode without segment list";
        }
      }
      description
        "PM probe not running reason";
    }

    typedef Pm-advert-reason {
      type enumeration {
        enum "no-advertisements" {
          value 0;
          description
            "Periodic timer expired. No advertisements have
           occured";
        }
        enum
          "periodic-advertisement-threshold-average" {
          value 1;
          description
            "Periodic timer expired. Average value threshold
           crossed";
        }
        enum
          "periodic-advertisement-threshold-minimum" {
          value 2;
          description
            "Periodic timer expired. Minimum value threshold
           crossed";
        }
        enum
          "periodic-advertisement-threshold-maximum" {
          value 3;
          description
            "Periodic timer expired. Maximum value threshold
           crossed";
        }
        enum
          "periodic-advertisement-threshold-variance" {
          value 4;
          description
            "Periodic timer expired. Variance value
           threshold crossed";
        }
        enum
          "accelerated-advertisement-threshold-average" {
          value 5;
          description
            "Accelerated average value threshold crossed";
        }
        enum
          "accelerated-advertisement-threshold-minimum" {
          value 6;
          description
            "Accelerated minimum value threshold crossed";
        }
        enum
          "accelerated-advertisement-threshold-maximum" {
          value 7;
          description
            "Accelerated maximum value threshold crossed";
        }
        enum
          "accelerated-advertisement-upper-bound-average" {
          value 8;
          description
            "Accelerated average value upper bound crossed";
        }
        enum
          "accelerated-advertisement-upper-bound-minimum" {
          value 9;
          description
            "Accelerated minimum value upper bound crossed";
        }
        enum
          "accelerated-advertisement-upper-bound-maximum" {
          value 10;
          description
            "Accelerated maximum value upper bound crossed";
        }
        enum
          "anomaly-check-advertisement-min-dynamic-delay" {
          value 11;
          description
            "Min delay A flag toggled and dynamic delay
           measurement is in effect";
        }
        enum
          "anomaly-check-advertisement-min-static-delay" {
          value 12;
          description
            "Min delay A flag toggled and static delay is in
           effect";
        }
        enum "advertisement-enabled" {
          value 13;
          description
            "Advertisement enabled";
        }
        enum "advertisement-disabled" {
          value 14;
          description
            "Advertisement disabled";
        }
        enum "session-unconfigured" {
          value 15;
          description "Session unconfigured";
        }
        enum "clear-cli-command" {
          value 16;
          description
            "Session cleared via CLI";
        }
        enum "advertise-delay-config" {
          value 17;
          description
            "Advertise delay config";
        }
        enum "advertise-delay-unconfig" {
          value 18;
          description
            "Advertise delay unconfig";
        }
        enum "received-control-code-error" {
          value 19;
          description
            "Recevied control code error, as per RFC 6374,
           from the responder";
        }
        enum "first-advertisement" {
          value 20;
          description "First advertisement";
        }
        enum "link-is-down" {
          value 21;
          description
            "Link is in down state";
        }
        enum "new-child-session" {
          value 22;
          description
            "Advertisement occured due to a new child
           session";
        }
        enum "invalid-measurement" {
          value 23;
          description
            "Performance measurement metrics withdrawn due
           to measurement error";
        }
        enum
          "dynamic-delay-measurement-in-effect" {
          value 24;
          description
            "Advertisement occured due to dynamic delay
           measurement is in effect";
        }
      }
      description "PM advertisement reason";
    }

    typedef Pm-xtc-srpolicy-origin {
      type enumeration {
        enum "candidate-path-origin-invalid" {
          value 0;
          description "Invalid Origin Type";
        }
        enum "candidate-path-origin-pce" {
          value 10;
          description
            "Candidate-path From PCE";
        }
        enum "candidate-path-origin-bgp" {
          value 20;
          description
            "Candidate-path From BGP";
        }
        enum
          "candidate-path-origin-configured" {
          value 30;
          description
            "Candidate-path From Configuration";
        }
      }
      description
        "Candidate-path Orign Type Shared By PM And XTC";
    }

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

    typedef Pm-ipv4-addr {
      type inet:ipv4-address;
      description "Pm ipv4 addr";
    }

    typedef Pm-addr {
      type enumeration {
        enum "ipv4" {
          value 0;
          description "IPv4";
        }
        enum "ipv6" {
          value 1;
          description "IPv6";
        }
        enum "unknown" {
          value 2;
          description "Unknown";
        }
      }
      description "Type of PM address";
    }

    grouping PM-NAME-PROFILE-UNION {
      description "PM Name profile union";
      container delay {
        when
          "../measurement-type = 'delay-measurement-type'" {
          description
            "../MeasurementType = 'DelayMeasurementType'";
        }
        description
          "Delay-Measurement name profile bag";
        uses PM-DELAY-TRANSPORT-PROFILE-BAG;
      }  // container delay

      container loss {
        when
          "../measurement-type = 'loss-measurement-type'" {
          description
            "../MeasurementType = 'LossMeasurementType'";
        }
        description
          "Loss-Measurement name profile bag";
        uses PM-LOSS-TRANSPORT-PROFILE-BAG;
      }  // container loss

      container liveness {
        when
          "../measurement-type = 'liveness-detection-type'" {
          description
            "../MeasurementType = 'LivenessDetectionType'";
        }
        description
          "Liveness-detection name profile bag";
        uses PM-LIVENESS-TRANSPORT-PROFILE-BAG;
      }  // container liveness

      leaf measurement-type {
        type Pm-measurement;
        description "MeasurementType";
      }
    }  // grouping PM-NAME-PROFILE-UNION

    grouping PM-NAME-PROFILE-BAG {
      description "PM Name Profile bag";
      container profile {
        description "Profile bag";
        uses PM-NAME-PROFILE-UNION;
      }  // container profile

      leaf name {
        type string;
        description "Profile name";
      }

      leaf transport-type {
        type Pm-transport;
        description "Transport type";
      }
    }  // grouping PM-NAME-PROFILE-BAG

    grouping PM-DR-SESSION-INFO {
      description "PM DR SESSION INFO";
      leaf distribution-record-name {
        type string;
        description
          "Name of the distribution record";
      }

      leaf lsp-id {
        type uint32;
        description "LSP ID";
      }

      leaf delay-notification-received {
        type boolean;
        description
          "True if the delay notification message was
         received";
      }

      leaf liveness-notification-received {
        type boolean;
        description
          "True if the liveness notification message was
         received";
      }
    }  // grouping PM-DR-SESSION-INFO

    grouping PM-DR-INFO {
      description
        "PM session distribution record information";
      leaf distribution-record-name {
        type string;
        description
          "Name of the distribution record";
      }

      leaf linecard-name {
        type string;
        description "Name of the linecard";
      }

      leaf record-creation-timestamp {
        type uint64;
        units "second";
        description
          "Time when the distribution record were created
         (seconds since Jan. 1, 1970)";
      }

      list session {
        description "List of DR sessions";
        uses PM-DR-SESSION-INFO;
      }  // list session
    }  // grouping PM-DR-INFO

    grouping PM-PPS-TRANSPORT-INFO {
      description
        "PPS resource information bag for one type of
       session";
      leaf pps-budget {
        type uint32;
        units "packet/s";
        description
          "Packets per second resource assigned for this
         type of session";
      }

      leaf requested-pps {
        type uint32;
        units "packet/s";
        description
          "Packets per second requested";
      }

      leaf current-multi-hop-burst-interval-stretch-factor {
        type uint32;
        units "percentage";
        description
          "Multi hop session's burst interval stretch
         factor percentage current value";
      }

      leaf dampened-multi-hop-burst-interval-stretch-factor {
        type uint32;
        units "percentage";
        description
          "Multi hop session's burst interval stretch
         factor percentage dampened value";
      }

      leaf inuse-multi-hop-burst-interval-stretch-factor {
        type uint32;
        units "percentage";
        description
          "Multi hop session's burst interval stretch
         factor percentage inuse value";
      }
    }  // grouping PM-PPS-TRANSPORT-INFO

    grouping PM-MULTI-PPS-POOL-BAG {
      description "Split type PPS pool";
      leaf maximum-pps-for-interface-session {
        type uint32;
        units "packet/s";
        description
          "Total maximum packets per second allowed for
         Interface sessions";
      }

      leaf total-pps-requested-for-interface-session {
        type uint32;
        units "packet/s";
        description
          "Total packets per second requested for Interface
         sessions";
      }

      leaf maximum-pps-for-mutihop-session {
        type uint32;
        units "packet/s";
        description
          "Total maximum packets per second allowed for
         multi-hop delay sessions";
      }

      leaf total-pps-requested-for-mh-session {
        type uint32;
        units "packet/s";
        description
          "Total packets per second requested for multi-hop
         delay sessions";
      }

      leaf minimum-pps-budget {
        type uint32;
        description
          "Guaranteed Minimum PPS budget per transport type";
      }

      leaf pps-budget-rebalance-threshold {
        type uint32;
        description
          "PPS budget will be rebalanced when the changed
         requested PPS crosses this threshold";
      }
    }  // grouping PM-MULTI-PPS-POOL-BAG

    grouping PM-SINGLE-PPS-POOL-BAG {
      description "Shared type PPS pool";
      leaf maximum-pps-for-all-session {
        type uint32;
        units "packet/s";
        description
          "Total maximum packets per second allowed for all
         the sessions";
      }

      leaf total-pps-requested {
        type uint32;
        units "packet/s";
        description
          "Total packets per second requested for all the
         sessions";
      }

      leaf minimum-pps-budget {
        type uint32;
        description
          "Guaranteed Minimum PPS budget per transport type";
      }

      leaf pps-budget-rebalance-threshold {
        type uint32;
        description
          "PPS budget will be rebalanced when the changed
         requested PPS crosses this threshold";
      }
    }  // grouping PM-SINGLE-PPS-POOL-BAG

    grouping PM-PPS-POOL-UNION {
      description "PPS Pool type";
      container single-pps-pool {
        when
          "../pps-pool-type = 'single-pps-pool'" {
          description
            "../PPSPoolType = 'SinglePPSPool'";
        }
        description "Single PPS pool";
        uses PM-SINGLE-PPS-POOL-BAG;
      }  // container single-pps-pool

      container multiple-pps-pool {
        when
          "../pps-pool-type = 'multiple-pps-pool'" {
          description
            "../PPSPoolType = 'MultiplePPSPool'";
        }
        description "Multiple PPS pool";
        uses PM-MULTI-PPS-POOL-BAG;
      }  // container multiple-pps-pool

      leaf pps-pool-type {
        type Pm-rl-pps-pool;
        description "PPSPoolType";
      }
    }  // grouping PM-PPS-POOL-UNION

    grouping PM-PPS-SUMMARY-BAG {
      description
        "PM Summary Rate Limiting bag";
      container pps-pool {
        description "PPS resource pool";
        uses PM-PPS-POOL-UNION;
      }  // container pps-pool

      container interface-session-info {
        description
          "Information for interface performance
         measurement sessions";
        uses PM-PPS-TRANSPORT-INFO;
      }  // container interface-session-info

      container sr-policy-session-info {
        description
          "Information for SR Policy performance
         measurement sessions";
        uses PM-PPS-TRANSPORT-INFO;
      }  // container sr-policy-session-info

      container rsvp-te-session-info {
        description
          "Information for RSVP-TE tunnel performance
         measurement sessions";
        uses PM-PPS-TRANSPORT-INFO;
      }  // container rsvp-te-session-info

      container endpoint-session-info {
        description
          "Information for Endpoint performance measurement
         sessions";
        uses PM-PPS-TRANSPORT-INFO;
      }  // container endpoint-session-info
    }  // grouping PM-PPS-SUMMARY-BAG

    grouping PM-LIVENESS-DETECTION-BAG {
      description
        "Liveness detection state information bag";
      leaf multiplier {
        type uint8;
        description "Detect multiplier";
      }

      leaf logging-state-change-enabled {
        type boolean;
        description
          "Emit syslog when the state of the session
         changes";
      }
    }  // grouping PM-LIVENESS-DETECTION-BAG

    grouping PM-LIVENESS-DETECTION-UNION {
      description
        "PM liveness detection profile union";
      container sr-policy-liveness-detection {
        when
          "../transport-type = 'sr-policy-transport-type'" {
          description
            "../TransportType = 'SRPolicyTransportType'";
        }
        description
          "Liveness detection info of SR Policy";
        uses PM-LIVENESS-DETECTION-BAG;
      }  // container sr-policy-liveness-detection

      container ep-liveness-detection {
        when
          "../transport-type = 'endpoiont-transport-type'" {
          description
            "../TransportType = 'EndpoiontTransportType'";
        }
        description
          "Liveness detection info of Endpoint";
        uses PM-LIVENESS-DETECTION-BAG;
      }  // container ep-liveness-detection

      leaf transport-type {
        type Pm-transport;
        description "TransportType";
      }
    }  // grouping PM-LIVENESS-DETECTION-UNION

    grouping PM-LIVENESS-TRANSPORT-PROFILE-BAG {
      description
        "PM interface liveness profile bag";
      container destination-sweeping-address {
        description
          "IPv4/IPv6 sweeping address";
        uses PM-IP-ADDR-TYPE;
      }  // container destination-sweeping-address

      container liveness-detection-config {
        description
          "Liveness detection config";
        uses PM-LIVENESS-DETECTION-UNION;
      }  // container liveness-detection-config

      leaf tos-dscp-value {
        type uint8;
        description
          "TOS DSCP value specified for protocol
         TWAMP-LIGHT";
      }

      leaf burst-interval {
        type uint32;
        description "Burst Interval (msec)";
      }

      leaf burst-interval-effective {
        type uint32;
        description
          "Effective Burst Interval (msec)";
      }

      leaf delay-measurement-mode {
        type Pm-delay-mode;
        description
          "Delay Measurement Mode Type";
      }

      leaf payload-type {
        type Pm-payload;
        description
          "Type of the probe packet payload";
      }

      leaf encap-mode {
        type Pm-encap-mode;
        description "Encap Mode";
      }

      leaf destination-sweeping-mode-enabled {
        type boolean;
        description
          "Measure liveness detection with ECMP hashing by
         sweeping destination address";
      }

      leaf destination-sweeping-range {
        type uint32;
        description
          "Number of IP addresses to sweep";
      }
    }  // grouping PM-LIVENESS-TRANSPORT-PROFILE-BAG

    grouping PM-LIVENESS-PROFILE-BAG {
      description "PM Liveness Profile bag";
      container sr-policy-liveness-profile {
        description
          "Profile of SR Policy liveness detection ";
        uses PM-LIVENESS-TRANSPORT-PROFILE-BAG;
      }  // container sr-policy-liveness-profile

      container endpoint-liveness-profile {
        description
          "Profile of Endpoint liveness detection ";
        uses PM-LIVENESS-TRANSPORT-PROFILE-BAG;
      }  // container endpoint-liveness-profile
    }  // grouping PM-LIVENESS-PROFILE-BAG

    grouping PM-LOSS-TRANSPORT-PROFILE-BAG {
      description
        "PM interface loss measurement profile bag";
      leaf probe-interval {
        type uint32;
        description "Probe Interval (sec)";
      }

      leaf encap-mode {
        type Pm-encap-mode;
        description "Encap Mode";
      }

      leaf periodic-advertisement-enabled {
        type boolean;
        description
          "Advertisement Periodic Enabled";
      }

      leaf periodic-advertisement-interval {
        type uint32;
        description
          "Advertisement Periodic Interval (sec)";
      }

      leaf effective-periodic-advertisement-interval {
        type uint32;
        description
          "Advertisement Periodic Effective (sec)";
      }

      leaf periodic-advertisement-threshold {
        type uint32;
        description
          "Advertisement Periodic Threshold (%)";
      }

      leaf periodic-advertisement-minimum-change {
        type uint32;
        description
          "Advertisement Periodic Minimum Change (uSec)";
      }

      leaf accelerated-advertisement-threshold {
        type uint32;
        description
          "Advertisement Accelerated Threshold (%)";
      }

      leaf accelerated-advertisement-minimum-change {
        type uint32;
        description
          "Advertisement Accelerated Minimum Change (uSec)";
      }

      leaf accelerated-advertisement-enabled {
        type boolean;
        description
          "Advertisement Accelerated Enabled";
      }
    }  // grouping PM-LOSS-TRANSPORT-PROFILE-BAG

    grouping PM-LOSS-PROFILE-BAG {
      description
        "PM loss measurement profile bag";
      container interface-delay-profile {
        description
          "Profile info of Interface loss measurement";
        uses PM-LOSS-TRANSPORT-PROFILE-BAG;
      }  // container interface-delay-profile
    }  // grouping PM-LOSS-PROFILE-BAG

    grouping PM-DELAY-TRANSPORT-PROFILE-BAG {
      description
        "PM interface delay profile bag";
      container destination-sweeping-address {
        description
          "IPv4/IPv6 sweeping address";
        uses PM-IP-ADDR-TYPE;
      }  // container destination-sweeping-address

      leaf probe-computation-interval {
        type uint32;
        description
          "Probe Computation Interval (sec)";
      }

      leaf probe-computation-interval-effective {
        type uint32;
        description
          "Effective Probe Computation Interval (sec)";
      }

      leaf tos-traffic-class-value {
        type uint8;
        description
          "TOS Traffic Class value specified for protocol
         PM-MPLS";
      }

      leaf tos-dscp-value {
        type uint8;
        description
          "TOS DSCP value specified for protocol
         TWAMP-LIGHT";
      }

      leaf burst-interval {
        type uint32;
        description "Burst Interval (msec)";
      }

      leaf burst-interval-effective {
        type uint32;
        description
          "Effective Burst Interval (msec)";
      }

      leaf burst-count {
        type uint32;
        description
          "Number of burst in one probe";
      }

      leaf delay-measurement-mode {
        type Pm-delay-mode;
        description
          "Delay Measurement Mode Type";
      }

      leaf router-alert {
        type boolean;
        description "IP router alert option";
      }

      leaf encap-mode {
        type Pm-encap-mode;
        description "Encap Mode";
      }

      leaf payload-type {
        type Pm-payload;
        description
          "Type of the probe packet payload";
      }

      leaf destination-sweeping-mode-enabled {
        type boolean;
        description
          "Measure the delay with ECMP hashing by sweeping
         destination address";
      }

      leaf destination-sweeping-range {
        type uint32;
        description
          "Number of IP addresses to sweep";
      }

      leaf periodic-advertisement-enabled {
        type boolean;
        description
          "Advertisement Periodic Enabled";
      }

      leaf periodic-advertisement-interval {
        type uint32;
        description
          "Advertisement Periodic Interval (sec)";
      }

      leaf periodic-advertisement-interval-effective {
        type uint32;
        description
          "Advertisement Periodic Effective (sec)";
      }

      leaf periodic-advertisement-threshold {
        type uint32;
        description
          "Advertisement Periodic Threshold (%)";
      }

      leaf periodic-advertisement-minimum-change {
        type uint32;
        description
          "Advertisement Periodic Minimum Change (uSec)";
      }

      leaf accelerated-advertisement-threshold {
        type uint32;
        description
          "Advertisement Accelerated Threshold (%)";
      }

      leaf accelerated-advertisement-minimum-change {
        type uint32;
        description
          "Advertisement Accelerated Minimum Change (uSec)";
      }

      leaf advertisement-logging-delay-exceeded-enabled {
        type boolean;
        description
          "Enable emitting syslog when delay exceeds
         threshold";
      }

      leaf accelerated-advertisement-enabled {
        type boolean;
        description
          "Advertisement Accelerated Enabled";
      }

      leaf advertisement-threshold-check-average-delay {
        type boolean;
        description
          "Check Average-delay For Advertisement Threshold
         Crossing";
      }

      leaf advertisement-threshold-check-minimum-delay {
        type boolean;
        description
          "Check Minimum-delay For Advertisement Threshold
         Crossing";
      }

      leaf advertisement-threshold-check-maximum-delay {
        type boolean;
        description
          "Check Maximum-delay For Advertisement Threshold
         Crossing";
      }

      leaf anomaly-check-advertisement-upper-bound {
        type uint32;
        description
          "Advertisement Anomaly Check Upper Bound (uSec)";
      }

      leaf anomaly-check-advertisement-lower-bound {
        type uint32;
        description
          "Advertisement Anomaly Check Lower Bound (uSec)";
      }

      leaf anomaly-check-advertisement-enabled {
        type boolean;
        description
          "Advertisement Anomaly Check Enabled";
      }
    }  // grouping PM-DELAY-TRANSPORT-PROFILE-BAG

    grouping PM-DELAY-PROFILE-BAG {
      description "PM Delay Profile bag";
      container interface-delay-profile {
        description
          "Profile of Interface delay measurement";
        uses PM-DELAY-TRANSPORT-PROFILE-BAG;
      }  // container interface-delay-profile

      container sr-policy-delay-profile {
        description
          "Profile of SR Policy delay measurement";
        uses PM-DELAY-TRANSPORT-PROFILE-BAG;
      }  // container sr-policy-delay-profile

      container rsvp-te-delay-profile {
        description
          "Profile of RSVP-TE delay measurement";
        uses PM-DELAY-TRANSPORT-PROFILE-BAG;
      }  // container rsvp-te-delay-profile

      container endpoint-delay-profile {
        description
          "Profile of Endpoint delay measurement";
        uses PM-DELAY-TRANSPORT-PROFILE-BAG;
      }  // container endpoint-delay-profile
    }  // grouping PM-DELAY-PROFILE-BAG

    grouping PM-PROFILE-BAG {
      description "PM Profile bag";
      container delay-profile {
        description
          "Profile info of delay measurement";
        uses PM-DELAY-PROFILE-BAG;
      }  // container delay-profile

      container loss-profile {
        description
          "Profile info of loss measurement";
        uses PM-LOSS-PROFILE-BAG;
      }  // container loss-profile

      container liveness-profile {
        description
          "Profile info of liveness detection";
        uses PM-LIVENESS-PROFILE-BAG;
      }  // container liveness-profile
    }  // grouping PM-PROFILE-BAG

    grouping PM-INTF-LAST-ADVERT-BAG {
      description
        "PM interface delay last advertisement bag";
      container last-advertisement {
        description
          "Last advertisement info for delay measurement";
        uses PM-SCB-LAST-ADVERT-BAG;
      }  // container last-advertisement
    }  // grouping PM-INTF-LAST-ADVERT-BAG

    grouping PM-INTF-LAST-PROBE-BAG {
      description
        "PM interface delay last probe bag";
      container last-probe {
        description
          "Last probe info for delay measurement";
        uses PM-PROBE-SAMPLE-BAG;
      }  // container last-probe
    }  // grouping PM-INTF-LAST-PROBE-BAG

    grouping PM-INTF-LAST-AGGR-BAG {
      description
        "PM interface delay last aggregation bag";
      container last-aggregation {
        description
          "Last aggregation interval";
        uses PM-AGGR-SAMPLE-BAG;
      }  // container last-aggregation

      leaf interface-name-xr {
        type string;
        description "Interface name";
      }

      leaf interface-handle {
        type uint32;
        description "Interface handle";
      }
    }  // grouping PM-INTF-LAST-AGGR-BAG

    grouping PM-INTF-HISTORY-BAG {
      description "PM interface history bag";
      container history-info {
        description
          "History info of the interface";
        uses PM-HISTORY-SAMPLE-UNION;
      }  // container history-info

      leaf interface-name-xr {
        type string;
        description "Name of the interface";
      }

      leaf interface-handle {
        type uint32;
        description
          "Ifhandle of the interface";
      }
    }  // grouping PM-INTF-HISTORY-BAG

    grouping PM-LOSS-ADVERTISEMENT-BAG {
      description " PM loss advertisement";
      leaf loss-percentage {
        type uint32;
        units "percentage";
        description "Packet loss percentage";
      }

      leaf timestamp-of-advertisement {
        type uint64;
        description
          "Advertisement timestamp";
      }

      leaf advertisement-reason {
        type Pm-advert-reason;
        description "Advertisement reason";
      }
    }  // grouping PM-LOSS-ADVERTISEMENT-BAG

    grouping PM-LOSS-WINDOW-BAG {
      description "PM loss window";
      leaf last-tx-packet-counter {
        type uint64;
        description "Last TX packet counter";
      }

      leaf last-rx-packet-counter {
        type uint64;
        description "Last RX packet counter";
      }

      leaf current-packet-tx-in-window {
        type uint64;
        description
          "Current packet TX in window";
      }

      leaf current-packet-rx-in-window {
        type uint64;
        description
          "Current packet RX in window";
      }

      leaf loss-percentage {
        type uint32;
        units "percentage";
        description "Packet loss percentage";
      }
    }  // grouping PM-LOSS-WINDOW-BAG

    grouping PM-INTF-LOSS-SUB-SESSION-BAG {
      description
        "Interface loss-measurement sub-session bag";
      container probe-window {
        description "Probe window loss";
        uses PM-LOSS-WINDOW-BAG;
      }  // container probe-window

      container periodic-window {
        description "Periodic window loss";
        uses PM-LOSS-WINDOW-BAG;
      }  // container periodic-window

      leaf interface-name {
        type string;
        description "Interface name";
      }

      leaf interface-handle {
        type uint32;
        description "Interface handle";
      }

      leaf interface-state-is-up {
        type boolean;
        description
          "True if interface state is up";
      }

      leaf session-id {
        type uint32;
        description "Session ID";
      }

      leaf rolling-average {
        type uint32;
        description "Rolling average";
      }
    }  // grouping PM-INTF-LOSS-SUB-SESSION-BAG

    grouping PM-INTF-LOSS-SESSION-BAG {
      description
        "Interface loss-measurement session";
      container probe-window {
        description "Probe window loss";
        uses PM-LOSS-WINDOW-BAG;
      }  // container probe-window

      container periodic-window {
        description "Periodic window loss";
        uses PM-LOSS-WINDOW-BAG;
      }  // container periodic-window

      container advertisement {
        description "Loss advertisement";
        uses PM-LOSS-ADVERTISEMENT-BAG;
      }  // container advertisement

      leaf session-id {
        type uint32;
        description "Session ID";
      }

      leaf rolling-average {
        type uint32;
        description "Rolling average";
      }

      leaf next-probe-start-time-remaining-in-millisec {
        type uint32;
        units "millisecond";
        description
          "Time in milliseconds until the next probe starts";
      }

      leaf probe-not-running-reason {
        type Pm-probe-running-error-reason;
        description
          "Reason why probe is not running";
      }

      list interface-loss-sub-session {
        description
          "Interface loss-measurement sub-sessions";
        uses PM-INTF-LOSS-SUB-SESSION-BAG;
      }  // list interface-loss-sub-session
    }  // grouping PM-INTF-LOSS-SESSION-BAG

    grouping PM-INTF-BAG {
      description "PM interface bag";
      container in-use-source-ip-address {
        description
          "Source IP address used for PM probe packet";
        uses PM-IP-ADDR-TYPE;
      }  // container in-use-source-ip-address

      container in-use-destination-ip-address {
        description
          "Destination IP address used for PM probe packet";
        uses PM-IP-ADDR-TYPE;
      }  // container in-use-destination-ip-address

      container next-hop {
        description
          "Nexthop address of the interface";
        uses PM-IP-ADDR-TYPE;
      }  // container next-hop

      container loss-measurement-session {
        description
          "Loss-measurement session";
        uses PM-INTF-LOSS-SESSION-BAG;
      }  // container loss-measurement-session

      leaf interface-name-xr {
        type string;
        description "Name of the interface";
      }

      leaf interface-handle {
        type uint32;
        description
          "Ifhandle of the interface";
      }

      leaf interface-state {
        type boolean;
        description "State of the interface";
      }

      leaf source-address {
        type inet:ipv4-address;
        description
          "Source address of the interface";
      }

      leaf source-v6-address {
        type inet:ipv6-address;
        description
          "Source IPv6 Address of the interface";
      }

      leaf link-local-iv6-address {
        type inet:ipv6-address;
        description
          "Link local IPv6 of the interface";
      }

      leaf source-mac-address {
        type yang:mac-address;
        description
          "Source Mac address of the interface";
      }

      leaf next-hop-mac-address {
        type yang:mac-address;
        description
          "Next-hop Mac address of the next-hop IP address";
      }

      leaf primary-vlan-tag {
        type uint16;
        description
          "Primary VLAN Tag of the interface";
      }

      leaf secondary-vlan-tag {
        type uint16;
        description
          "Secondary VLAN Tag of the interface";
      }

      list delay-measurement-session {
        description
          "List of all the Delay-measurement sessions of
         the interface";
        uses PM-SCB-BAG;
      }  // list delay-measurement-session
    }  // grouping PM-INTF-BAG

    grouping PM-LOSS-TRANSPORT-SUMMARY-BAG {
      description
        "PM interface loss summary bag";
      container loss-transport-counters {
        description
          "TODO: PM loss counters for a transport types";
        uses PM-DELAY-COUNTERS-INFO-BAG;
      }  // container loss-transport-counters

      leaf total-loss-sessions {
        type uint32;
        description
          "Number of loss measurement sessions enabled";
      }
    }  // grouping PM-LOSS-TRANSPORT-SUMMARY-BAG

    grouping PM-LOSS-SUMMARY-BAG {
      description "PM Loss Summary bag";
      container interface-loss-summary {
        description "Interface loss summary";
        uses PM-LOSS-TRANSPORT-SUMMARY-BAG;
      }  // container interface-loss-summary

      container delay-global-counters {
        description
          "PM delay global counters";
        uses PM-DELAY-GLOBAL-COUNTERS-BAG;
      }  // container delay-global-counters
    }  // grouping PM-LOSS-SUMMARY-BAG

    grouping PM-DELAY-GLOBAL-COUNTERS-BAG {
      description "PM global counters";
      leaf query-packets-sent {
        type uint64;
        description
          "Number of query packets sent";
      }

      leaf query-packets-received {
        type uint64;
        description
          "Number of received query packets";
      }

      leaf received-packet-error-invalid-session-id {
        type uint64;
        description
          "Number of received packet error caused by
         invalid session ID";
      }

      leaf received-packet-error-no-session {
        type uint64;
        description
          "Number of received packet error caused by no
         session";
      }
    }  // grouping PM-DELAY-GLOBAL-COUNTERS-BAG

    grouping PM-DELAY-SESSION-COUNTER-BAG {
      description
        "PM delay session counter info bag";
      leaf total-delay-sessions {
        type uint32;
        description
          "Number of delay measurement sessions enabled";
      }

      leaf total-probe-running-with-error-delay-sessions {
        type uint32;
        description
          "Number of running with error delay measurement
         sessions";
      }

      leaf total-probe-running-delay-sessions {
        type uint32;
        description
          "Number of running delay measurement sessions";
      }

      leaf total-probe-running-ipv4-delay-sessions {
        type uint32;
        description
          "Number of running ipv4 delay measurement
         sessions";
      }

      leaf total-probe-running-ipv6-delay-sessions {
        type uint32;
        description
          "Number of running ipv6 delay measurement
         sessions";
      }

      leaf total-probe-running-mpls-delay-sessions {
        type uint32;
        description
          "Number of running mpls delay measurement
         sessions";
      }
    }  // grouping PM-DELAY-SESSION-COUNTER-BAG

    grouping PM-DELAY-TRANSPORT-SUMMARY-BAG {
      description
        "PM interface delay summary bag";
      container delay-session-counters {
        description
          "PM delay session counters for a transport type";
        uses PM-DELAY-SESSION-COUNTER-BAG;
      }  // container delay-session-counters

      container delay-transport-counters {
        description
          "PM delay counters for a transport types";
        uses PM-DELAY-COUNTERS-INFO-BAG;
      }  // container delay-transport-counters
    }  // grouping PM-DELAY-TRANSPORT-SUMMARY-BAG

    grouping PM-DELAY-SUMMARY-BAG {
      description "PM Delay Summary bag";
      container endpoint-delay-summary {
        description
          "Summary of Endpoint delay measurement";
        uses PM-DELAY-TRANSPORT-SUMMARY-BAG;
      }  // container endpoint-delay-summary

      container interface-delay-summary {
        description
          "Summary info of Interface delay measurement";
        uses PM-DELAY-TRANSPORT-SUMMARY-BAG;
      }  // container interface-delay-summary

      container sr-policy-delay-summary {
        description
          "Summary of SR Policy delay measurement";
        uses PM-DELAY-TRANSPORT-SUMMARY-BAG;
      }  // container sr-policy-delay-summary

      container rsvp-te-delay-summary {
        description
          "Summary of RSVP-TE delay measurement";
        uses PM-DELAY-TRANSPORT-SUMMARY-BAG;
      }  // container rsvp-te-delay-summary

      container delay-global-counters {
        description
          "Global counters for PM delay measurement";
        uses PM-DELAY-GLOBAL-COUNTERS-BAG;
      }  // container delay-global-counters
    }  // grouping PM-DELAY-SUMMARY-BAG

    grouping PM-SUMMARY-BAG {
      description "PM Summary bag";
      container delay-summary {
        description
          "Summary info of delay measurement";
        uses PM-DELAY-SUMMARY-BAG;
      }  // container delay-summary

      container loss-summary {
        description "Loss summary";
        uses PM-LOSS-SUMMARY-BAG;
      }  // container loss-summary

      leaf total-endpoints {
        type uint32;
        description "Number of endpoints";
      }

      leaf total-interfaces {
        type uint32;
        description "Number of interfaces";
      }

      leaf total-sr-policies {
        type uint32;
        description "Number of SR Policies";
      }

      leaf total-rsvp-te-tunnels {
        type uint32;
        description
          "Number of RSVP-TE tunnels";
      }
    }  // grouping PM-SUMMARY-BAG

    grouping PM-SESSION-ENDPOINT-BAG {
      description "PM Endpoint session";
      container end-point-dest-address {
        description
          "Endpoint destination address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-dest-address

      container end-point-src-address {
        description
          "Endpoint source address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-src-address

      container session {
        description "Endpoint session";
        uses PM-SCB-BAG;
      }  // container session

      leaf endpoint-name {
        type string;
        description "Endpoint name";
      }

      leaf vrf-name {
        type string;
        description "VRF name";
      }

      leaf segment-list-name {
        type string;
        description "Segment-list name";
      }
    }  // grouping PM-SESSION-ENDPOINT-BAG

    grouping PM-SESSION-SRPOLICY-BAG {
      description "PM SR Policy session";
      container end-point-address {
        description "End point address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-address

      container atomic-path {
        description
          "SR Policy atomic path session";
        uses PM-SRPOLICY-ATOMIC-PATH-BAG;
      }  // container atomic-path

      leaf color {
        type uint32;
        description "Color";
      }

      leaf policy-name {
        type string;
        description "Policy name";
      }

      leaf instance {
        type uint32;
        description "Session instance";
      }

      leaf preference {
        type uint32;
        description "Preference";
      }

      leaf origin {
        type Pm-xtc-srpolicy-origin;
        description "Protocol origin";
      }

      leaf discriminator {
        type uint32;
        description "Discriminator";
      }

      leaf segment-list-name {
        type string;
        description "Segment-list name";
      }
    }  // grouping PM-SESSION-SRPOLICY-BAG

    grouping PM-SESSION-RSVPTE-BAG {
      description "PM RSVP-TE session";
      container lsp-session {
        description "RSVP-TE LSP session";
        uses PM-RSVPTE-LSP-DELAY-BAG;
      }  // container lsp-session

      leaf tunnel-name {
        type string;
        description "RSVP-TE tunnel name";
      }

      leaf interface-handle {
        type uint32;
        description "Interface handle";
      }
    }  // grouping PM-SESSION-RSVPTE-BAG

    grouping PM-SESSION-INTF-BAG {
      description "PM interface session";
      container next-hop {
        description "Nexthop address";
        uses PM-IP-ADDR-TYPE;
      }  // container next-hop

      container session {
        description "Interface session";
        uses PM-SCB-BAG;
      }  // container session

      leaf interface-name {
        type string;
        description "Interface name";
      }

      leaf interface-handle {
        type uint32;
        description "Interface handle";
      }
    }  // grouping PM-SESSION-INTF-BAG

    grouping PM-SESSION-BAG-UNION {
      description "PM session union";
      container interface-session {
        when
          "../type = 'interface-transport-type'" {
          description
            "../type = 'InterfaceTransportType'";
        }
        description "Interface session";
        uses PM-SESSION-INTF-BAG;
      }  // container interface-session

      container rsvpte-tunnel-session {
        when
          "../type = 'rsvp-te-transport-type'" {
          description
            "../type = 'RSVP_TETransportType'";
        }
        description "RSVP-TE tunnel session";
        uses PM-SESSION-RSVPTE-BAG;
      }  // container rsvpte-tunnel-session

      container sr-policy-session {
        when
          "../type = 'sr-policy-transport-type'" {
          description
            "../type = 'SRPolicyTransportType'";
        }
        description "SR Policy session";
        uses PM-SESSION-SRPOLICY-BAG;
      }  // container sr-policy-session

      container endpoint-session {
        when
          "../type = 'endpoiont-transport-type'" {
          description
            "../type = 'EndpoiontTransportType'";
        }
        description "Endpoint session";
        uses PM-SESSION-ENDPOINT-BAG;
      }  // container endpoint-session

      leaf type {
        type Pm-transport;
        description "type";
      }
    }  // grouping PM-SESSION-BAG-UNION

    grouping PM-SESSION-BAG {
      description "PM session";
      container session {
        description "Session union";
        uses PM-SESSION-BAG-UNION;
      }  // container session

      leaf measurement-type {
        type Pm-measurement;
        description "Measurement type";
      }
    }  // grouping PM-SESSION-BAG

    grouping PM-SCB-BAG {
      description
        "PM interface delay measurement session bag";
      container current-probe {
        description
          "Information for the current probe";
        uses PM-SCB-PROBE-BAG;
      }  // container current-probe

      container session-counters {
        description
          "Counters info for the session";
        uses PM-DELAY-COUNTERS-INFO-BAG;
      }  // container session-counters

      container last-advertisement-information {
        description
          "Last advertisement information of the session";
        uses PM-SCB-LAST-ADVERT-BAG;
      }  // container last-advertisement-information

      container next-advertisement-information {
        description
          "Next advertisement information of the session";
        uses PM-SCB-NEXT-ADVERT-BAG;
      }  // container next-advertisement-information

      container last-notification-control-code {
        description
          "Last notifcation control code received of the
         session";
        uses PM-SCB-CONTROL-CODE;
      }  // container last-notification-control-code

      container last-error-control-code {
        description
          "Last error control code received of the session";
        uses PM-SCB-CONTROL-CODE;
      }  // container last-error-control-code

      container responder-address {
        description
          "Address of the Responder";
        uses PM-IP-ADDR-TYPE;
      }  // container responder-address

      leaf session-id {
        type uint32;
        description "ID of the session";
      }

      leaf transport-type {
        type Pm-transport;
        description
          "Transport Type of the session";
      }

      leaf measurement-type {
        type Pm-measurement;
        description
          "Measurement Type of the session";
      }

      leaf profile-name {
        type string;
        description
          "Interface delay-measurement profile name";
      }

      leaf periodic-advertisement-interval-in-sec {
        type uint32;
        units "second";
        description
          "Interval of periodic advertisement in seconds";
      }

      leaf query-number-of-hops {
        type uint8;
        description
          "Number of hops traversed by the query packet";
      }

      list probe-history {
        description "Current probe history";
        uses PM-SCB-SAMPLE-BAG;
      }  // list probe-history
    }  // grouping PM-SCB-BAG

    grouping PM-ENDPOINT-DETAIL-SEGMENT-LIST-BAG {
      description
        "PM Endpoint segment-list bag";
      leaf segment-list-name {
        type string;
        description
          "Name of the segment-list";
      }

      list segment {
        description "List of segments";
        uses PM-SEGMENT-BAG;
      }  // list segment

      list delay-measurement-session {
        description
          "List of all the Delay-measurement sessions of
         this segment-list";
        uses PM-SCB-BAG;
      }  // list delay-measurement-session
    }  // grouping PM-ENDPOINT-DETAIL-SEGMENT-LIST-BAG

    grouping PM-ENDPOINT-CONSOLIDATED-DETAIL-BAG {
      description
        "PM endpoint consolidated details bag";
      leaf ep-cons-profile-name {
        type string;
        description
          "Endpoint delay-measurement profile name";
      }

      list ep-segment-list {
        description
          "List of segment-lists in the endpoint";
        uses PM-ENDPOINT-DETAIL-SEGMENT-LIST-BAG;
      }  // list ep-segment-list
    }  // grouping PM-ENDPOINT-CONSOLIDATED-DETAIL-BAG

    grouping PM-ENDPOINT-DETAIL {
      description "PM Endpoint instance";
      container end-point-address {
        description
          "IPv4/IPv6 End point address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-address

      container end-point-session-source-address {
        description
          "IPv4/IPv6 End point session source address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-session-source-address

      leaf endpoint-name {
        type string;
        description
          "Name of the endpoint session";
      }

      leaf vrf-name {
        type string;
        description "Name of the VRF";
      }

      leaf description {
        type string;
        description "Endpoint Description";
      }

      list ep-consolidated-detail {
        description
          "Consolidated Details to hold all segment lists
         of this endpoint";
        uses PM-ENDPOINT-CONSOLIDATED-DETAIL-BAG;
      }  // list ep-consolidated-detail
    }  // grouping PM-ENDPOINT-DETAIL

    grouping PM-ENDPOINT-COMMON {
      description "PM Endpoint common bag";
      leaf endpoint-name-xr {
        type string;
        description
          "Name of the endpoint session";
      }

      list endpoint-delay {
        description
          "List of Endpoint delay measurement";
        uses PM-ENDPOINT-DETAIL;
      }  // list endpoint-delay

      list endpoint-liveness {
        description
          "List of Endpoint liveness";
        uses PM-ENDPOINT-LIVENESS;
      }  // list endpoint-liveness
    }  // grouping PM-ENDPOINT-COMMON

    grouping PM-ENDPOINT-SEGMENT-LIST-COUNTERS-BAG {
      description
        "PM endpoint segment-list counters bag";
      container counters {
        description "Segment-list counters";
        uses PM-DELAY-COUNTERS-INFO-BAG;
      }  // container counters

      leaf segment-list-name {
        type string;
        description
          "Segment-list name, not set if path is dynamic";
      }

      list segment {
        description "List of segments";
        uses PM-SEGMENT-BAG;
      }  // list segment
    }  // grouping PM-ENDPOINT-SEGMENT-LIST-COUNTERS-BAG

    grouping PM-ENDPOINT-CONSOLIDATED-COUNTERS-DATA-BAG {
      description
        "PM endpoint consolidated counters data bag";
      list segment-list-counter {
        description
          "List of counters for segment-lists in this
         consolidated data";
        uses PM-ENDPOINT-SEGMENT-LIST-COUNTERS-BAG;
      }  // list segment-list-counter
    }  // grouping PM-ENDPOINT-CONSOLIDATED-COUNTERS-DATA-BAG

    grouping PM-ENDPOINT-COUNTERS-BAG {
      description "PM endpoint counters bag";
      leaf endpoint-name-xr {
        type string;
        description
          "Name of the endpoint session";
      }

      list consolidated-counters-data {
        description
          "List of consolidated data counters";
        uses PM-ENDPOINT-CONSOLIDATED-COUNTERS-DATA-BAG;
      }  // list consolidated-counters-data
    }  // grouping PM-ENDPOINT-COUNTERS-BAG

    grouping PM-ENDPOINT-HISTORY-SEGMENT-LIST-BAG {
      description
        "PM endpoint segment-list history bag";
      container history-info {
        description
          "History info of the segment-list";
        uses PM-HISTORY-SAMPLE-UNION;
      }  // container history-info

      leaf segment-list-name {
        type string;
        description
          "Segment-list name, not set if path is dynamic";
      }
    }  // grouping PM-ENDPOINT-HISTORY-SEGMENT-LIST-BAG

    grouping PM-ENDPOINT-HISTORY-BAG {
      description "PM endpoint history bag";
      container end-point-address {
        description
          "IPv4/IPv6 End point address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-address

      container end-point-session-source-address {
        description
          "IPv4/IPv6 End point session source address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-session-source-address

      leaf endpoint-name-xr {
        type string;
        description
          "Name of the endpoint session";
      }

      leaf vrf-name {
        type string;
        description "Name of the VRF";
      }

      leaf ep-liveness-detection-enabled {
        type boolean;
        description
          "True if liveness detection is enabled for the
         endpoint";
      }

      list ep-segment-lists-history {
        description "List of segment-lists";
        uses PM-ENDPOINT-HISTORY-SEGMENT-LIST-BAG;
      }  // list ep-segment-lists-history
    }  // grouping PM-ENDPOINT-HISTORY-BAG

    grouping PM-ENDPOINT-SEGMENT-LIST-METRICS-BAG {
      description
        "PM Endpoint segment-list metrics bag";
      container metrics {
        description "Segment-list metrics";
        uses PM-VALUES-BAG;
      }  // container metrics

      leaf segment-list-name {
        type string;
        description
          "Segment-list name, not set if path is dynamic";
      }

      leaf timestamp {
        type uint64;
        units "millisecond";
        description
          "Time when the metrics were computed
         (milliseconds since Jan. 1, 1970)";
      }

      list segment {
        description "List of segments";
        uses PM-SEGMENT-BAG;
      }  // list segment
    }  // grouping PM-ENDPOINT-SEGMENT-LIST-METRICS-BAG

    grouping PM-ENDPOINT-CONSOLIDATED-METRICS-BAG {
      description
        "PM Endpoint consolidated metrics bag";
      list ep-segment-list {
        description "List of segment-lists";
        uses PM-ENDPOINT-SEGMENT-LIST-METRICS-BAG;
      }  // list ep-segment-list
    }  // grouping PM-ENDPOINT-CONSOLIDATED-METRICS-BAG

    grouping PM-ENDPOINT-METRICS-BAG {
      description "PM Endpoint metrics bag";
      leaf endpoint-name-xr {
        type string;
        description "Name of the Endpoint";
      }

      list ep-consolidated-metric {
        description
          "List of Consolidated Metrics of all segment
         lists";
        uses PM-ENDPOINT-CONSOLIDATED-METRICS-BAG;
      }  // list ep-consolidated-metric
    }  // grouping PM-ENDPOINT-METRICS-BAG

    grouping PM-ENDPOINT-LIVENESS-SEGMENT-LIST-BAG {
      description
        "PM endpoint liveness segment list bag";
      container ep-liveness-info {
        description
          "Information of endpoint liveness detection
         session";
        uses PM-LIVENESS-STATE-INFO-BAG;
      }  // container ep-liveness-info

      leaf segment-list-name {
        type string;
        description
          "Name of the segment-list";
      }

      leaf session-id {
        type uint32;
        description "ID of the session";
      }

      leaf liveness-detection-enabled {
        type boolean;
        description
          "Liveness detection is enabled";
      }

      leaf probe-not-running-reason {
        type Pm-probe-running-error-reason;
        description
          "Reason why probe is not running";
      }

      list segment {
        description "List of segments";
        uses PM-SEGMENT-BAG;
      }  // list segment
    }  // grouping PM-ENDPOINT-LIVENESS-SEGMENT-LIST-BAG

    grouping PM-ENDPOINT-CONSOLIDATED-LIVENESS-BAG {
      description
        "PM endpoint consolidated liveness bag";
      leaf ep-live-profile-name {
        type string;
        description
          "Endpoint liveness-detection profile name";
      }

      list ep-liveness-segment-list {
        description
          "List of liveness segment-lists in the endpoint";
        uses PM-ENDPOINT-LIVENESS-SEGMENT-LIST-BAG;
      }  // list ep-liveness-segment-list
    }  // grouping PM-ENDPOINT-CONSOLIDATED-LIVENESS-BAG

    grouping PM-ENDPOINT-LIVENESS {
      description
        "PM Endpoint liveness-detection bag";
      container end-point-address {
        description
          "IPv4/IPv6 End point address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-address

      container end-point-session-source-address {
        description
          "IPv4/IPv6 End point session source address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-session-source-address

      leaf endpoint-name-xr {
        type string;
        description
          "Name of the endpoint session";
      }

      leaf vrf-name {
        type string;
        description "Name of the VRF";
      }

      list ep-consolidated-liveness {
        description
          "Consolidated liveness details of this endpoint";
        uses PM-ENDPOINT-CONSOLIDATED-LIVENESS-BAG;
      }  // list ep-consolidated-liveness
    }  // grouping PM-ENDPOINT-LIVENESS

    grouping PM-CAP-HW-OFFLOAD-INFO {
      description
        "PM hardware offload capability informaation bag";
      leaf hardware-offload-npu-count {
        type uint32;
        description
          "Number of NPU available for Hardware Offload";
      }

      leaf hardware-offload-max-supported-inject-pps-limit-per-npu {
        type uint32;
        units "packet/s";
        description
          "Packets per second limit for Hardware Offload
         inject per NPU";
      }

      leaf hardware-offload-min-supported-inject-interval-per-npu {
        type uint32;
        description
          "Interval in msec supported for Hardware Offload
         per NPU";
      }

      leaf hardware-offload-maxupported-session-number-per-npu {
        type uint32;
        description
          "Max number of sessions supported for Hardware
         Offload per NPU";
      }
    }  // grouping PM-CAP-HW-OFFLOAD-INFO

    grouping PM-CAP-PDDLL-INFO {
      description
        "PM PD-DLL capability informaation bag";
      leaf pd-dll-max-supported-inject-pps-limit {
        type uint32;
        units "packet/s";
        description
          "Packets per second limit for PD-DLL inject";
      }

      leaf pd-dll-min-supported-inject-interval {
        type uint32;
        description
          "Interval in msec supported for PD-DLL inject";
      }
    }  // grouping PM-CAP-PDDLL-INFO

    grouping PM-CAP-SPIO-INFO {
      description
        "PM SPIO capability informaation bag";
      leaf spio-max-supported-inject-pps-limit {
        type uint32;
        units "packet/s";
        description
          "Packets per second limit for SPIO inject";
      }

      leaf spio-min-supported-inject-interval {
        type uint32;
        description
          "Interval in msec supported for SPIO inject";
      }
    }  // grouping PM-CAP-SPIO-INFO

    grouping PM-CAP-NETIO-INFO {
      description
        "PM NETIO capability informaation bag";
      leaf netio-max-supported-inject-pps-limit {
        type uint32;
        units "packet/s";
        description
          "Packets per second limit for NETIO inject";
      }

      leaf netio-min-supported-inject-interval {
        type uint32;
        description
          "Interval in msec supported for NETIO inject";
      }
    }  // grouping PM-CAP-NETIO-INFO

    grouping PM-CAPABILITY-INFO {
      description
        "Performance-measurement capability information";
      container netio-capability-info {
        description
          "Capability information for NETIO";
        uses PM-CAP-NETIO-INFO;
      }  // container netio-capability-info

      container spio-capability-info {
        description
          "Capability information for SPIO";
        uses PM-CAP-SPIO-INFO;
      }  // container spio-capability-info

      container pd-dll-capability-info {
        description
          "Capability information for PD-DLL";
        uses PM-CAP-PDDLL-INFO;
      }  // container pd-dll-capability-info

      container hardware-offload-capability-info {
        description
          "Capability information for Hardware offload";
        uses PM-CAP-HW-OFFLOAD-INFO;
      }  // container hardware-offload-capability-info

      leaf netio-supported {
        type boolean;
        description
          "True if NETIO is supported on this location for
         Performance-measurement";
      }

      leaf spio-supported {
        type boolean;
        description
          "True if SPIO is supported on this location for
         Performance-measurement";
      }

      leaf pd-dll-supported {
        type boolean;
        description
          "True if PD-DLL is supported on this location for
         Performance-measurement";
      }

      leaf hardware-offload-supported {
        type boolean;
        description
          "True if Hardware Offload is supported on this
         location for Performance-measurement";
      }

      leaf remote-punt-supportec {
        type boolean;
        description
          "True if packet remote punt is supported on this
         location for Performance-measurement";
      }

      leaf linecard-distribution-supported {
        type boolean;
        description
          "True if linecard distribution is supported on
         this location";
      }
    }  // grouping PM-CAPABILITY-INFO

    grouping PM-CAPABILITY-BAG {
      description
        "PM Capability information bag";
      container performance-measurement-capability-info {
        description "PM capability info";
        uses PM-CAPABILITY-INFO;
      }  // container performance-measurement-capability-info

      leaf performance-measurement-supported {
        type boolean;
        description
          "True if performance-measurement is supported on
         this location";
      }
    }  // grouping PM-CAPABILITY-BAG

    grouping PM-RSVPTE-LSP-HISTORY-BAG {
      description
        "PM RSVP-TE LSP history bag";
      container history-union {
        description
          "History info of the RSVP-TE LSP";
        uses PM-HISTORY-SAMPLE-UNION;
      }  // container history-union

      leaf lsp-id {
        type uint32;
        description "LSP ID";
      }
    }  // grouping PM-RSVPTE-LSP-HISTORY-BAG

    grouping PM-RSVPTE-HISTORY-BAG {
      description
        "PM RSVP-TE tunnel history bag";
      leaf tunnel-name-xr {
        type string;
        description "RSVP-TE tunnel name";
      }

      list lsp {
        description "List of LSPs";
        uses PM-RSVPTE-LSP-HISTORY-BAG;
      }  // list lsp
    }  // grouping PM-RSVPTE-HISTORY-BAG

    grouping PM-RSVPTE-LSP-DELAY-METRICS-BAG {
      description
        "PM RSVP-TE LSP delay metrics bag";
      container metrics {
        description "LSP metrics";
        uses PM-VALUES-BAG;
      }  // container metrics

      leaf lsp-id {
        type uint32;
        description "LSP ID";
      }

      leaf timestamp {
        type uint64;
        units "millisecond";
        description
          "Time when the metrics were computed
         (milliseconds since Jan. 1, 1970)";
      }
    }  // grouping PM-RSVPTE-LSP-DELAY-METRICS-BAG

    grouping PM-RSVPTE-DELAY-METRICS-BAG {
      description
        "PM RSVP-TE tunnel delay metrics bag";
      leaf tunnel-name-xr {
        type string;
        description "RSVP-TE tunnel name";
      }

      list lsp {
        description "List of LSPs";
        uses PM-RSVPTE-LSP-DELAY-METRICS-BAG;
      }  // list lsp
    }  // grouping PM-RSVPTE-DELAY-METRICS-BAG

    grouping PM-RSVPTE-LSP-DELAY-BAG {
      description "PM RSVP-TE LSP delay bag";
      container last-probe-results {
        description
          "Last probe results of LSP";
        uses PM-SCB-PROBE-RESULTS-BAG;
      }  // container last-probe-results

      container current-probe {
        description
          "Information for the current probe of the LSP";
        uses PM-SCB-PROBE-BAG;
      }  // container current-probe

      container last-advertisement-information {
        description
          "Last advertisement information of the RSVP-TE
         LSP";
        uses PM-SCB-LAST-ADVERT-BAG;
      }  // container last-advertisement-information

      container next-advertisement-information {
        description
          "Next advertisement information of the RSVP-TE
         LSP";
        uses PM-SCB-NEXT-ADVERT-BAG;
      }  // container next-advertisement-information

      container last-notification-control-code {
        description
          "Last notifcation control code received of the
         RSVP-TE LSP";
        uses PM-SCB-CONTROL-CODE;
      }  // container last-notification-control-code

      container last-error-control-code {
        description
          "Last error control code received of the RSVP-TE
         LSP";
        uses PM-SCB-CONTROL-CODE;
      }  // container last-error-control-code

      container responder-address {
        description
          "Address of the Responder";
        uses PM-IP-ADDR-TYPE;
      }  // container responder-address

      leaf session-id {
        type uint32;
        description "Session ID of the LSP";
      }

      leaf lsp-id {
        type uint32;
        description "LSP ID";
      }

      leaf lsp-source-ipv4-address {
        type inet:ipv4-address;
        description
          "LSP Source IPv4 Address";
      }

      leaf periodic-advertisement-interval-in-sec {
        type uint32;
        units "second";
        description
          "Interval of periodic advertisement in seconds";
      }

      leaf query-number-of-hops {
        type uint8;
        description
          "Number of hops traversed by the query packet";
      }

      list probe-history {
        description
          "Current probe history of the LSP";
        uses PM-SCB-SAMPLE-BAG;
      }  // list probe-history
    }  // grouping PM-RSVPTE-LSP-DELAY-BAG

    grouping PM-RSVPTE-BAG {
      description "PM RSVP-TE bag";
      leaf tunnel-name-xr {
        type string;
        description "RSVP-TE tunnel name";
      }

      leaf interface-handle {
        type uint32;
        description "Ifhandle of the tunnel";
      }

      leaf tunnel-destination-ipv4-address {
        type inet:ipv4-address;
        description
          "IPv4 address destination of the tunnel";
      }

      list rsvptelsp-delay-session {
        description
          "RSVP-TE LSP delay-measurement sessions";
        uses PM-RSVPTE-LSP-DELAY-BAG;
      }  // list rsvptelsp-delay-session
    }  // grouping PM-RSVPTE-BAG

    grouping PM-RSVPTE-LSP-DELAY-COUNTERS-BAG {
      description
        "RSVP-TE LSP delay counters bag";
      container counters {
        description "LSP counters";
        uses PM-DELAY-COUNTERS-INFO-BAG;
      }  // container counters

      leaf lsp-id {
        type uint32;
        description "LSP ID";
      }
    }  // grouping PM-RSVPTE-LSP-DELAY-COUNTERS-BAG

    grouping PM-RSVPTE-COUNTERS-BAG {
      description
        "RSVP-TE tunnel counters bag";
      leaf tunnel-name-xr {
        type string;
        description "RSVP-TE tunnel name";
      }

      list rsvptelsp-delay-counter {
        description "List of LSPs";
        uses PM-RSVPTE-LSP-DELAY-COUNTERS-BAG;
      }  // list rsvptelsp-delay-counter
    }  // grouping PM-RSVPTE-COUNTERS-BAG

    grouping PM-SRPOLICY-SEGMENT-LIST-COUNTERS-BAG {
      description
        "PM segment-list counters bag";
      container counters {
        description "Segment-list counters";
        uses PM-DELAY-COUNTERS-INFO-BAG;
      }  // container counters

      leaf segment-list-name {
        type string;
        description
          "Segment-list name, not set if path is dynamic";
      }

      list segment {
        description "List of segments";
        uses PM-SEGMENT-BAG;
      }  // list segment
    }  // grouping PM-SRPOLICY-SEGMENT-LIST-COUNTERS-BAG

    grouping PM-ENDPOINT-EXCLUSIVE-DELAY-COUNTERS-INFO-BAG {
      description
        "PM exclusive counters bag for Endpoint delay";
      leaf query-packets-sent-error-sl-label-missing {
        type uint64;
        description
          "Number of query packets sent error caused by
         Missing Segment list Labels";
      }

      leaf liveness-detection-missed-count {
        type uint64;
        description
          "Number of missed packets";
      }
    }  // grouping PM-ENDPOINT-EXCLUSIVE-DELAY-COUNTERS-INFO-BAG

    grouping PM-SRPOLICY-EXCLUSIVE-DELAY-COUNTERS-INFO-BAG {
      description
        "PM exclusive counters bag for SR Policy delay";
      leaf liveness-detection-missed-count {
        type uint64;
        description
          "Number of missed packets";
      }
    }  // grouping PM-SRPOLICY-EXCLUSIVE-DELAY-COUNTERS-INFO-BAG

    grouping PM-INTF-EXCLUSIVE-DELAY-COUNTERS-INFO-BAG {
      description
        "PM exclusive counters bag for interface delay";
      leaf query-packet-sent-error-interface-down {
        type uint64;
        description
          "Number of query packets sent error caused by
         interface down";
      }

      leaf query-packet-sent-error-no-mpls-caps {
        type uint64;
        description
          "Number of query packets sent error caused by no
         MPLS caps";
      }

      leaf query-packet-sent-error-ipv4-down-with-v4-next-hop {
        type uint64;
        description
          "Number of query packets sent error caused by
         IPv4 protocl in down state with configured IPv4
         next hop";
      }

      leaf query-packet-sent-error-ipv6-down-with-v6-next-hop {
        type uint64;
        description
          "Number of query packets sent error caused by
         IPv6 protocl in down state with configured IPv6
         next hop";
      }

      leaf query-packet-sent-error-ipv4ipv6-down-without-next-hop {
        type uint64;
        description
          "Number of query packets sent error caused by
         both IPv4 and IPv6 protocl in down state without
         configured next hop";
      }

      leaf query-packet-sent-error-next-hop-mac-missing {
        type uint64;
        description
          "Number of query packets sent error caused by
         missing next hop MAC";
      }
    }  // grouping PM-INTF-EXCLUSIVE-DELAY-COUNTERS-INFO-BAG

    grouping PM-EXCLUSIVE-DELAY-COUNTERS-INFO-UNION {
      description
        "Counters info type for interface, RSVP-TE LSP, SR
       Policy and Endpoint";
      container interface-exclusive-counters {
        when
          "../transport-type = 'interface-transport-type'" {
          description
            "../TransportType = 'InterfaceTransportType'";
        }
        description
          "Counters exclusive for interface";
        uses PM-INTF-EXCLUSIVE-DELAY-COUNTERS-INFO-BAG;
      }  // container interface-exclusive-counters

      container sr-policy-exclusive-counters {
        when
          "../transport-type = 'sr-policy-transport-type'" {
          description
            "../TransportType = 'SRPolicyTransportType'";
        }
        description
          "Counters exclusive for SR Policies";
        uses PM-SRPOLICY-EXCLUSIVE-DELAY-COUNTERS-INFO-BAG;
      }  // container sr-policy-exclusive-counters

      container endpoint-exclusive-counters {
        when
          "../transport-type = 'endpoiont-transport-type'" {
          description
            "../TransportType = 'EndpoiontTransportType'";
        }
        description
          "Counters exclusive for Endpoint";
        uses PM-ENDPOINT-EXCLUSIVE-DELAY-COUNTERS-INFO-BAG;
      }  // container endpoint-exclusive-counters

      leaf transport-type {
        type Pm-transport;
        description "TransportType";
      }
    }  // grouping PM-EXCLUSIVE-DELAY-COUNTERS-INFO-UNION

    grouping PM-QUERIER-DELAY-COUNTERS-BAG {
      description
        "PM delay querier counters";
      leaf query-packets-sent {
        type uint64;
        description
          "Number of query packets sent";
      }

      leaf query-packet-sent-errors {
        type uint64;
        description
          "Number of query packets sent error";
      }

      leaf query-packet-sent-error-no-ip-address {
        type uint64;
        description
          "Number of query packets sent error caused by no
         IP address";
      }

      leaf query-packets-received {
        type uint64;
        description
          "Number of received query packets";
      }

      leaf received-packet-error-negative-delay {
        type uint64;
        description
          "Number of packet error caused by receiving
         negative delay";
      }

      leaf received-packet-error-delay-exceeds-threshold {
        type uint64;
        description
          "Number of packet error caused by measured delay
         is invalid due to exceeding threshold";
      }

      leaf received-packet-error-missing-tx-timestamp {
        type uint64;
        description
          "Number of packet error caused by received packet
         is missing Tx timestamp";
      }

      leaf received-packet-error-missing-rx-timestamp {
        type uint64;
        description
          "Number of packet error caused by received packet
         is missing Rx timestamp";
      }

      leaf received-packet-error-probe-full {
        type uint64;
        description
          "Number of packet error caused by receiving
         packet when probe is full";
      }

      leaf received-packet-error-probe-not-started {
        type uint64;
        description
          "Number of packet error caused by receiving
         packet when probe is not started";
      }

      leaf received-packet-control-code-error {
        type uint64;
        description
          "Number of packet error caused by a control code
         error from responder";
      }

      leaf received-packet-control-code-notification {
        type uint64;
        description
          "Number of packet error caused by a control code
         notification from responder";
      }

      leaf probes-started {
        type uint64;
        description
          "Number of probes started";
      }

      leaf probes-complete {
        type uint64;
        description
          "Number of probes completed";
      }

      leaf probes-incomplete {
        type uint64;
        description
          "Number of probes incomplete";
      }

      leaf advertisement {
        type uint64;
        description
          "Number of advertisements";
      }
    }  // grouping PM-QUERIER-DELAY-COUNTERS-BAG

    grouping PM-DELAY-COUNTERS-INFO-BAG {
      description
        "PM delay counters info bag";
      container generic-counters {
        description
          "Generic counters for a PM interface instance";
        uses PM-QUERIER-DELAY-COUNTERS-BAG;
      }  // container generic-counters

      container exclusive-counters {
        description
          "Exclusive counters for a PM interface instance";
        uses PM-EXCLUSIVE-DELAY-COUNTERS-INFO-UNION;
      }  // container exclusive-counters
    }  // grouping PM-DELAY-COUNTERS-INFO-BAG

    grouping PM-SRPOLICY-CANDIDATE-PATH-COUNTERS-BAG {
      description
        "PM candidate-path counters bag";
      container counters {
        description
          "Candidate-path counters";
        uses PM-DELAY-COUNTERS-INFO-BAG;
      }  // container counters

      leaf instance {
        type uint32;
        description "Session instance";
      }

      leaf preference {
        type uint32;
        description
          "Preference of the candidate-path";
      }

      leaf origin {
        type Pm-xtc-srpolicy-origin;
        description "Protocol origin";
      }

      leaf discriminator {
        type uint32;
        description
          "Discriminator of the candidate-path";
      }

      list segment-list-counter {
        description
          "List of counters for segment-lists in this
         candidate-path";
        uses PM-SRPOLICY-SEGMENT-LIST-COUNTERS-BAG;
      }  // list segment-list-counter
    }  // grouping PM-SRPOLICY-CANDIDATE-PATH-COUNTERS-BAG

    grouping PM-SRPOLICY-COUNTERS-BAG {
      description
        "PM SR Policy counters bag";
      leaf policy-name-xr {
        type string;
        description "Name of the SR Policy";
      }

      list candidate-counter {
        description
          "List of candidate path counters";
        uses PM-SRPOLICY-CANDIDATE-PATH-COUNTERS-BAG;
      }  // list candidate-counter
    }  // grouping PM-SRPOLICY-COUNTERS-BAG

    grouping PM-SRPOLICY-ATOMIC-PATH-LIVENESS {
      description
        "PM SR Policy atomic path liveness detection bag";
      container liveness-detection-info {
        description
          "Information of liveness detection session state";
        uses PM-LIVENESS-STATE-INFO-BAG;
      }  // container liveness-detection-info

      list hop-address {
        description "Hop addresses list";
        uses PM-IP-ADDR-TYPE;
      }  // list hop-address

      list label {
        description "MPLS labels";
        leaf entry {
          type uint32;
          description "MPLS labels";
        }
      }  // list label
    }  // grouping PM-SRPOLICY-ATOMIC-PATH-LIVENESS

    grouping PM-SRPOLICY-SEGMENT-LIST-LIVENESS {
      description
        "PM SR Policy segment-list liveness detection bag";
      container liveness-detection-info {
        description
          "Information of liveness detection session state";
        uses PM-LIVENESS-STATE-INFO-BAG;
      }  // container liveness-detection-info

      leaf segment-list-name {
        type string;
        description
          "Segment-list name, not set if path is dynamic";
      }

      list segment {
        description "List of segments";
        uses PM-SEGMENT-BAG;
      }  // list segment

      list atomic-path {
        description "List of atomic paths";
        uses PM-SRPOLICY-ATOMIC-PATH-LIVENESS;
      }  // list atomic-path
    }  // grouping PM-SRPOLICY-SEGMENT-LIST-LIVENESS

    grouping PM-SRPOLICY-CANDIDATE-PATH-LIVENESS {
      description
        "PM SR Policy candidate-path liveness detection
       bag";
      container liveness-detection-info {
        description
          "Information of liveness detection session state";
        uses PM-LIVENESS-STATE-INFO-BAG;
      }  // container liveness-detection-info

      leaf instance {
        type uint32;
        description "Session instance";
      }

      leaf preference {
        type uint32;
        description
          "Preference of the candidate-path";
      }

      leaf origin {
        type Pm-xtc-srpolicy-origin;
        description "Protocol origin";
      }

      leaf discriminator {
        type uint32;
        description
          "Discriminator of the candidate-path";
      }

      list segment-list {
        description "List of segment-lists";
        uses PM-SRPOLICY-SEGMENT-LIST-LIVENESS;
      }  // list segment-list
    }  // grouping PM-SRPOLICY-CANDIDATE-PATH-LIVENESS

    grouping PM-SRPOLICY-LIVENESS {
      description
        "PM SR Policy liveness detection bag";
      container end-point-address {
        description
          "IPv4/IPv6 End point address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-address

      leaf policy-name {
        type string;
        description "Name of the SR Policy";
      }

      leaf color {
        type uint32;
        description "Color";
      }

      leaf liveness-detection-enabled {
        type boolean;
        description
          "True if liveness detection is enabled for the
         policy";
      }

      list candidate-path {
        description
          "List of candidate-paths";
        uses PM-SRPOLICY-CANDIDATE-PATH-LIVENESS;
      }  // list candidate-path
    }  // grouping PM-SRPOLICY-LIVENESS

    grouping PM-SRPOLICY-HISTORY-ATOMIC-PATH-BAG {
      description
        "PM SR Policy atomic path history bag";
      container history-info {
        description
          "History info of the atomic path ";
        uses PM-HISTORY-SAMPLE-UNION;
      }  // container history-info

      list hop-address {
        description "Hop addresses list";
        uses PM-IP-ADDR-TYPE;
      }  // list hop-address
    }  // grouping PM-SRPOLICY-HISTORY-ATOMIC-PATH-BAG

    grouping PM-SRPOLICY-HISTORY-SEGMENT-LIST-BAG {
      description
        "PM SR Policy segment-list history bag";
      container history-info {
        description
          "History info of the segment-list";
        uses PM-HISTORY-SAMPLE-UNION;
      }  // container history-info

      leaf segment-list-name {
        type string;
        description
          "Segment-list name, not set if path is dynamic";
      }

      list segment {
        description "List of segments";
        uses PM-SEGMENT-BAG;
      }  // list segment

      list atomic-paths-history {
        description "List of atomic paths";
        uses PM-SRPOLICY-HISTORY-ATOMIC-PATH-BAG;
      }  // list atomic-paths-history
    }  // grouping PM-SRPOLICY-HISTORY-SEGMENT-LIST-BAG

    grouping PM-LM-ADV-SAMPLE-BAG {
      description "LM advertisement sample";
      leaf timestamp {
        type uint64;
        units "millisecond";
        description
          "Timestamp (milliseconds since Jan. 1, 1970)";
      }

      leaf advertisement-reason {
        type Pm-advert-reason;
        description "Advertisement reason";
      }

      leaf loss-percentage {
        type uint32;
        units "percentage";
        description "Packet loss percentage";
      }
    }  // grouping PM-LM-ADV-SAMPLE-BAG

    grouping PM-LM-ADV-HISTORY-BAG {
      description
        "PM LM advertisement history";
      list lm-advertisement-history {
        description
          "LM advertisement history";
        uses PM-LM-ADV-SAMPLE-BAG;
      }  // list lm-advertisement-history
    }  // grouping PM-LM-ADV-HISTORY-BAG

    grouping PM-LM-AGGR-SAMPLE-BAG {
      description "LM probe sample";
      leaf timestamp {
        type uint64;
        units "millisecond";
        description
          "Timestamp (milliseconds since Jan. 1, 1970)";
      }

      leaf num-sent-packet {
        type uint64;
        description
          "Number of packets been sent in this aggregation
         interval";
      }

      leaf num-received-packet {
        type uint64;
        description
          "Number of packets been received in this
         aggregation interval";
      }

      leaf loss-percentage {
        type uint32;
        units "percentage";
        description "Packet loss percentage";
      }
    }  // grouping PM-LM-AGGR-SAMPLE-BAG

    grouping PM-LM-AGGR-HISTORY-BAG {
      description
        "PM LM aggregation history";
      list lm-aggregated-hisotry {
        description "LM aggregation history";
        uses PM-LM-AGGR-SAMPLE-BAG;
      }  // list lm-aggregated-hisotry
    }  // grouping PM-LM-AGGR-HISTORY-BAG

    grouping PM-LM-PKT-SAMPLE-BAG {
      description "LM packet sample";
      leaf timestamp {
        type uint64;
        units "millisecond";
        description
          "Timestamp (milliseconds since Jan. 1, 1970)";
      }

      leaf tx-counter {
        type uint64;
        description "TX counter";
      }

      leaf rx-counter {
        type uint64;
        description "RX RX counter";
      }
    }  // grouping PM-LM-PKT-SAMPLE-BAG

    grouping PM-LM-PKT-HISTORY-BAG {
      description "PM LM packet history";
      list lm-packet-hisotry {
        description "LM packet history";
        uses PM-LM-PKT-SAMPLE-BAG;
      }  // list lm-packet-hisotry
    }  // grouping PM-LM-PKT-HISTORY-BAG

    grouping PM-LM-PROBE-SAMPLE-BAG {
      description "LM probe sample";
      leaf timestamp {
        type uint64;
        units "millisecond";
        description
          "Timestamp (milliseconds since Jan. 1, 1970)";
      }

      leaf num-sent-packet {
        type uint64;
        description
          "Number of packets been sent in this probe
         interval";
      }

      leaf num-received-packet {
        type uint64;
        description
          "Number of packets been received in this probe
         interval";
      }

      leaf loss-percentage {
        type uint32;
        units "percentage";
        description "Packet loss percentage";
      }
    }  // grouping PM-LM-PROBE-SAMPLE-BAG

    grouping PM-LM-PROBE-HISTORY-BAG {
      description "PM LM probe history";
      list lm-probe-hisotry {
        description "LM probe history";
        uses PM-LM-PROBE-SAMPLE-BAG;
      }  // list lm-probe-hisotry
    }  // grouping PM-LM-PROBE-HISTORY-BAG

    grouping PM-LIVE-SAMPLE-BAG {
      description
        "PM liveness session history bag";
      leaf liveness-state-change-timestamp {
        type uint64;
        description
          "Time liveness session state was changed";
      }

      leaf liveness-state-is-up {
        type boolean;
        description
          "True if liveness session is in UP state";
      }
    }  // grouping PM-LIVE-SAMPLE-BAG

    grouping PM-LIVE-HISTORY-BAG {
      description "PM liveness history";
      list liveness-hisotry {
        description
          "List of records of liveness history";
        uses PM-LIVE-SAMPLE-BAG;
      }  // list liveness-hisotry
    }  // grouping PM-LIVE-HISTORY-BAG

    grouping PM-ADV-SAMPLE-BAG {
      description
        "PM advertisement history bag";
      container advertised-values {
        description
          "Advertised delay information";
        uses PM-VALUES-BAG;
      }  // container advertised-values

      leaf advertisement-timestamp {
        type uint64;
        units "millisecond";
        description
          "Time advertisement was done (milliseconds since
         Jan. 1, 1970)";
      }

      leaf advertisement-reason {
        type Pm-advert-reason;
        description
          "Reason for advertisement";
      }
    }  // grouping PM-ADV-SAMPLE-BAG

    grouping PM-ADV-HISTORY-BAG {
      description "PM advertisement history";
      list advertisement-history {
        description
          "List of samples of advertisement history records";
        uses PM-ADV-SAMPLE-BAG;
      }  // list advertisement-history
    }  // grouping PM-ADV-HISTORY-BAG

    grouping PM-AGGR-SAMPLE-BAG {
      description
        "PM aggregated delay probe history bag";
      container aggregated-probe-values {
        description
          "Summarised results of the aggregated probe";
        uses PM-VALUES-BAG;
      }  // container aggregated-probe-values

      leaf aggregation-timestamp {
        type uint64;
        units "millisecond";
        description
          "Time probe aggregation was done (milliseconds
         since Jan. 1, 1970)";
      }
    }  // grouping PM-AGGR-SAMPLE-BAG

    grouping PM-AGGR-HISTORY-BAG {
      description "PM aggregated history";
      list aggregated-history {
        description
          "List of samples of aggregation history records";
        uses PM-AGGR-SAMPLE-BAG;
      }  // list aggregated-history
    }  // grouping PM-AGGR-HISTORY-BAG

    grouping PM-PROBE-SAMPLE-BAG {
      description
        "PM delay probe history bag";
      container probe-values {
        description
          "Summarized results of the probe";
        uses PM-VALUES-BAG;
      }  // container probe-values

      leaf probe-start-timestamp {
        type uint64;
        units "millisecond";
        description
          "Time last probe started (milliseconds since Jan.
         1, 1970)";
      }

      leaf packets-sent {
        type uint32;
        description
          "Number of query packets sent";
      }

      leaf packets-received {
        type uint32;
        description
          "Number of query Packets received";
      }
    }  // grouping PM-PROBE-SAMPLE-BAG

    grouping PM-PROBE-HISTORY-BAG {
      description "PM probe history";
      list probe-history {
        description
          "List of samples of probe history records";
        uses PM-PROBE-SAMPLE-BAG;
      }  // list probe-history
    }  // grouping PM-PROBE-HISTORY-BAG

    grouping PM-HISTORY-SAMPLE-UNION {
      description "PM history sample union";
      container probe-history {
        when
          "../history-type = 'history-type-probe'" {
          description
            "../HistoryType = 'HistoryTypeProbe'";
        }
        description
          "Info of delay-measurement probe history";
        uses PM-PROBE-HISTORY-BAG;
      }  // container probe-history

      container aggregated-history {
        when
          "../history-type = 'history-type-aggregated'" {
          description
            "../HistoryType = 'HistoryTypeAggregated'";
        }
        description
          "Info of delay-measurement aggregation history";
        uses PM-AGGR-HISTORY-BAG;
      }  // container aggregated-history

      container advertisement-history {
        when
          "../history-type = 'history-type-advertisement'" {
          description
            "../HistoryType = 'HistoryTypeAdvertisement'";
        }
        description
          "Info of delay-measurement advertisement history";
        uses PM-ADV-HISTORY-BAG;
      }  // container advertisement-history

      container liveness-history {
        when
          "../history-type = 'history-type-liveness-state'" {
          description
            "../HistoryType = 'HistoryTypeLivenessState'";
        }
        description
          "Info of liveness session history";
        uses PM-LIVE-HISTORY-BAG;
      }  // container liveness-history

      container lm-probe-history {
        when
          "../history-type = 'history-type-lm-probe'" {
          description
            "../HistoryType = 'HistoryTypeLMProbe'";
        }
        description
          "Info of loss-measurement probe history";
        uses PM-LM-PROBE-HISTORY-BAG;
      }  // container lm-probe-history

      container lm-packet-history {
        when
          "../history-type = 'history-type-lm-packet'" {
          description
            "../HistoryType = 'HistoryTypeLMPacket'";
        }
        description
          "Info of loss-measurement packet history";
        uses PM-LM-PKT-HISTORY-BAG;
      }  // container lm-packet-history

      container lm-aggregated-history {
        when
          "../history-type = 'history-type-lm-aggregated'" {
          description
            "../HistoryType = 'HistoryTypeLMAggregated'";
        }
        description
          "Info of loss-measurement aggregation history";
        uses PM-LM-AGGR-HISTORY-BAG;
      }  // container lm-aggregated-history

      container lm-advertisement-history {
        when
          "../history-type = 'history-type-lm-advertisement'" {
          description
            "../HistoryType = 'HistoryTypeLMAdvertisement'";
        }
        description
          "Info of loss-measurement advertisement history";
        uses PM-LM-ADV-HISTORY-BAG;
      }  // container lm-advertisement-history

      leaf history-type {
        type Pm-history;
        description "HistoryType";
      }
    }  // grouping PM-HISTORY-SAMPLE-UNION

    grouping PM-SRPOLICY-HISTORY-CANDIDATE-PATH-BAG {
      description
        "PM SR Policy segment-list history bag";
      container history-info {
        description
          "History info of the candidate-path";
        uses PM-HISTORY-SAMPLE-UNION;
      }  // container history-info

      leaf preference {
        type uint32;
        description
          "Preference of the candidate-path";
      }

      leaf origin {
        type Pm-xtc-srpolicy-origin;
        description "Protocol origin";
      }

      leaf discriminator {
        type uint32;
        description
          "Discriminator of the candidate-path";
      }

      list segment-lists-history {
        description "List of segment-lists";
        uses PM-SRPOLICY-HISTORY-SEGMENT-LIST-BAG;
      }  // list segment-lists-history
    }  // grouping PM-SRPOLICY-HISTORY-CANDIDATE-PATH-BAG

    grouping PM-SRPOLICY-HISTORY-BAG {
      description "PM SR Policy history bag";
      container end-point-address {
        description
          "IPv4/IPv6 End point address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-address

      leaf color {
        type uint32;
        description "Color";
      }

      leaf policy-name {
        type string;
        description "Name of the SR Policy";
      }

      list candidate-paths-history {
        description
          "List of candidate-paths";
        uses PM-SRPOLICY-HISTORY-CANDIDATE-PATH-BAG;
      }  // list candidate-paths-history
    }  // grouping PM-SRPOLICY-HISTORY-BAG

    grouping PM-SRPOLICY-METRICS-ATOMIC-PATH-BAG {
      description
        "PM SR Policy atomic path metrics bag";
      container metrics {
        description "Atomic Path metrics";
        uses PM-VALUES-BAG;
      }  // container metrics

      list hop-address {
        description "Hop addresses list";
        uses PM-IP-ADDR-TYPE;
      }  // list hop-address

      list label {
        description "MPLS labels";
        leaf entry {
          type uint32;
          description "MPLS labels";
        }
      }  // list label
    }  // grouping PM-SRPOLICY-METRICS-ATOMIC-PATH-BAG

    grouping PM-SRPOLICY-SEGMENT-LIST-METRICS-BAG {
      description
        "PM SR Policy segment-list metrics bag";
      container metrics {
        description "Segment-list metrics";
        uses PM-VALUES-BAG;
      }  // container metrics

      leaf segment-list-name {
        type string;
        description
          "Segment-list name, not set if path is dynamic";
      }

      list segment {
        description "List of segments";
        uses PM-SEGMENT-BAG;
      }  // list segment

      list atomic-path {
        description "List of atomic paths";
        uses PM-SRPOLICY-METRICS-ATOMIC-PATH-BAG;
      }  // list atomic-path
    }  // grouping PM-SRPOLICY-SEGMENT-LIST-METRICS-BAG

    grouping PM-SRPOLICY-CANDIDATE-PATH-METRICS-BAG {
      description
        "PM SR Policy candidate-path metrics bag";
      container metrics {
        description "Candidate-path metrics";
        uses PM-VALUES-BAG;
      }  // container metrics

      leaf instance {
        type uint32;
        description "Session instance";
      }

      leaf preference {
        type uint32;
        description
          "Preference of the candidate-path";
      }

      leaf origin {
        type Pm-xtc-srpolicy-origin;
        description "Protocol origin";
      }

      leaf discriminator {
        type uint32;
        description
          "Discriminator of the candidate-path";
      }

      leaf timestamp {
        type uint64;
        units "millisecond";
        description
          "Time when the metrics were computed
         (milliseconds since Jan. 1, 1970)";
      }

      list segment-list {
        description "List of segment-lists";
        uses PM-SRPOLICY-SEGMENT-LIST-METRICS-BAG;
      }  // list segment-list
    }  // grouping PM-SRPOLICY-CANDIDATE-PATH-METRICS-BAG

    grouping PM-SRPOLICY-METRICS-BAG {
      description "PM SR Policy metrics bag";
      leaf policy-name {
        type string;
        description "Name of the SR Policy";
      }

      list candidate-path {
        description
          "List of candidate-paths";
        uses PM-SRPOLICY-CANDIDATE-PATH-METRICS-BAG;
      }  // list candidate-path
    }  // grouping PM-SRPOLICY-METRICS-BAG

    grouping PM-SCB-SAMPLE-BAG {
      description
        "PM delay probe sample bag";
      leaf measurement-value {
        type uint64;
        description
          "Measurement value (nsec)";
      }

      leaf query-timestamp {
        type uint64;
        units "millisecond";
        description
          "Timestamp when the measurement was taken
         (milliseconds since Jan. 1, 1970)";
      }
    }  // grouping PM-SCB-SAMPLE-BAG

    grouping PM-SRPOLICY-ATOMIC-PATH-BAG {
      description
        "PM SR Policy atomic path bag";
      container last-advertisement-information {
        description
          "Last advertisement information of the atomic
         path";
        uses PM-SCB-LAST-ADVERT-BAG;
      }  // container last-advertisement-information

      container next-advertisement-information {
        description
          "Current advertisement information of the atomic
         path";
        uses PM-SCB-NEXT-ADVERT-BAG;
      }  // container next-advertisement-information

      container current-probe-results {
        description
          "Current probe results of the atomic path";
        uses PM-SCB-PROBE-RESULTS-BAG;
      }  // container current-probe-results

      container last-probe-results {
        description
          "Last probe results of the atomic path";
        uses PM-SCB-PROBE-RESULTS-BAG;
      }  // container last-probe-results

      container liveness-detection-info {
        description
          "Information for liveness detection";
        uses PM-LIVENESS-STATE-INFO-BAG;
      }  // container liveness-detection-info

      container last-notification-control-code {
        description
          "Last notifcation control code received of the
         atomic path";
        uses PM-SCB-CONTROL-CODE;
      }  // container last-notification-control-code

      container last-error-control-code {
        description
          "Last error control code received of the atomic
         path";
        uses PM-SCB-CONTROL-CODE;
      }  // container last-error-control-code

      container responder-address {
        description
          "Address of the Responder";
        uses PM-IP-ADDR-TYPE;
      }  // container responder-address

      leaf outgoing-interface {
        type uint32;
        description
          "Outgoing interface of the atomic path";
      }

      leaf session-id {
        type uint32;
        description
          "Session ID of the atomic path";
      }

      leaf liveness-detection-enabled {
        type boolean;
        description
          "Liveness detection is enabled";
      }

      leaf query-number-of-hops {
        type uint8;
        description
          "Number of hops traversed by the query packet";
      }

      list hop-address {
        description "Hop addresses list";
        uses PM-IP-ADDR-TYPE;
      }  // list hop-address

      list label {
        description
          "MPLS labels of the atomic path";
        leaf entry {
          type uint32;
          description
            "MPLS labels of the atomic path";
        }
      }  // list label

      list current-probe-history {
        description
          "Current probe history of the atomic path";
        uses PM-SCB-SAMPLE-BAG;
      }  // list current-probe-history
    }  // grouping PM-SRPOLICY-ATOMIC-PATH-BAG

    grouping PM-SEGMENT-BAG {
      description "PM segment information";
      container ip-address {
        description "Segment IP address";
        uses PM-IP-ADDR-TYPE;
      }  // container ip-address

      leaf mpls-label {
        type uint32;
        description "Segment mpls label";
      }
    }  // grouping PM-SEGMENT-BAG

    grouping PM-SRPOLICY-SEGMENT-LIST-BAG {
      description
        "PM SR Policy segment-list bag";
      container last-advertisement-information {
        description
          "Last advertisement information of the
         segment-list";
        uses PM-SCB-LAST-ADVERT-BAG;
      }  // container last-advertisement-information

      container next-advertisement-information {
        description
          "Current advertisement information of the
         segment-list";
        uses PM-SCB-NEXT-ADVERT-BAG;
      }  // container next-advertisement-information

      container current-probe-results {
        description
          "Current probe results of the segment-list";
        uses PM-SCB-PROBE-RESULTS-BAG;
      }  // container current-probe-results

      container last-probe-results {
        description
          "Last probe results of the segment-list";
        uses PM-SCB-PROBE-RESULTS-BAG;
      }  // container last-probe-results

      container liveness-detection-info {
        description
          "Information for liveness detection";
        uses PM-LIVENESS-STATE-INFO-BAG;
      }  // container liveness-detection-info

      container last-notification-control-code {
        description
          "Last notifcation control code received of the
         segment-list";
        uses PM-SCB-CONTROL-CODE;
      }  // container last-notification-control-code

      container last-error-control-code {
        description
          "Last error control code received of the
         segment-list";
        uses PM-SCB-CONTROL-CODE;
      }  // container last-error-control-code

      leaf segment-list-name {
        type string;
        description
          "Name of the segment-list";
      }

      leaf atomic-path-total-count {
        type uint32;
        description
          "Number of atomic paths in the segment-list";
      }

      leaf liveness-detection-enabled {
        type boolean;
        description
          "Liveness detection is enabled";
      }

      list segment {
        description "List of segments";
        uses PM-SEGMENT-BAG;
      }  // list segment

      list atomic-path {
        description "List of atomic paths";
        uses PM-SRPOLICY-ATOMIC-PATH-BAG;
      }  // list atomic-path
    }  // grouping PM-SRPOLICY-SEGMENT-LIST-BAG

    grouping PM-LIVENESS-STATE-INFO-BAG {
      description
        "Liveness detection session state information";
      leaf session-is-up {
        type boolean;
        description "Liveness session state";
      }

      leaf miss-count {
        type uint32;
        description
          "Number of continuously missed probe packets";
      }

      leaf last-session-state-change-timestamp {
        type uint64;
        description
          "Timestamp of the last liveness session state
         change";
      }
    }  // grouping PM-LIVENESS-STATE-INFO-BAG

    grouping PM-SCB-CONTROL-CODE {
      description
        "Last received control code";
      leaf control-code {
        type uint8;
        description
          "MPLS PM RFC 6374 control code";
      }

      leaf timestamp {
        type uint64;
        units "millisecond";
        description
          "Received timestamp of the control code
         (milliseconds since Jan. 1, 1970)";
      }
    }  // grouping PM-SCB-CONTROL-CODE

    grouping PM-SCB-PROBE-BAG {
      description "PM delay probe bag";
      container probe-results {
        description
          "Summarized  results of the current probe";
        uses PM-VALUES-BAG;
      }  // container probe-results

      leaf probe-start-time-stamp {
        type uint64;
        units "millisecond";
        description
          "Timestamp in milliseconds of the current probe
         start (milliseconds since Jan. 1, 1970)";
      }

      leaf next-probe-start-time-remaining-in-millisec {
        type uint32;
        units "millisecond";
        description
          "Time in milliseconds until the next probe starts";
      }

      leaf next-packet-sent-time-remaining-in-millisec {
        type uint32;
        units "millisecond";
        description
          "Time in milliseconds until the next packet is
         sent";
      }

      leaf burst-interval {
        type uint32;
        units "millisecond";
        description
          "Burst interval (in milliseconds)";
      }

      leaf burst-interval-is-stretched {
        type boolean;
        description
          "True if the burst interval has been stretched
         for packet rate-limiting";
      }

      leaf number-of-packets-sent {
        type uint32;
        description
          "Number of packets sent in the current probe";
      }

      leaf number-of-packets-received {
        type uint32;
        description
          "Number of packets received in the current probe";
      }

      leaf probe-not-running-reason {
        type Pm-probe-running-error-reason;
        description
          "Reason why probe is not running";
      }
    }  // grouping PM-SCB-PROBE-BAG

    grouping PM-SCB-PROBE-RESULTS-BAG {
      description "PM probe results bag";
      container probe-values {
        description
          "Summarized results of the probe";
        uses PM-VALUES-BAG;
      }  // container probe-values

      leaf number-of-packets-sent {
        type uint32;
        description
          "Number of packets sent in the probe";
      }

      leaf number-of-packets-received {
        type uint32;
        description
          "Number of packets received in the probe";
      }
    }  // grouping PM-SCB-PROBE-RESULTS-BAG

    grouping PM-SCB-NEXT-ADVERT-BAG {
      description
        "PM delay next advertisement bag";
      container advertisement-interval-values {
        description
          "Next advertisement values";
        uses PM-VALUES-BAG;
      }  // container advertisement-interval-values

      leaf advertisement-interval-probes-remaining {
        type uint32;
        description
          "Probes remaining until next periodic
         advertisement check";
      }

      leaf rolling-average {
        type uint32;
        description
          "Rolling average value (uSec)";
      }
    }  // grouping PM-SCB-NEXT-ADVERT-BAG

    grouping PM-VALUES-BAG {
      description
        "PM delay summarized delay values";
      leaf average {
        type uint32;
        description "Average value (uSec)";
      }

      leaf minimum {
        type uint32;
        description "Minimum value (uSec)";
      }

      leaf maximum {
        type uint32;
        description "Maximum value (uSec)";
      }

      leaf variance {
        type uint32;
        description "Variance value (uSec)";
      }
    }  // grouping PM-VALUES-BAG

    grouping PM-SCB-LAST-ADVERT-BAG {
      description
        "PM delay last advertisement bag";
      container advertised-values {
        description
          "Advertised delay information";
        uses PM-VALUES-BAG;
      }  // container advertised-values

      leaf time-of-advertisement {
        type uint64;
        units "millisecond";
        description
          "Time of the advertisement (milliseconds since
         Jan. 1, 1970)";
      }

      leaf advertisement-reason {
        type Pm-advert-reason;
        description
          "Reason for advertisement";
      }

      leaf aflag-set {
        type boolean;
        description "A flag is set";
      }
    }  // grouping PM-SCB-LAST-ADVERT-BAG

    grouping PM-SRPOLICY-CANDIDATE-PATH-BAG {
      description
        "PM SR Policy candidate-path bag";
      container last-advertisement-information {
        description
          "Last advertisement information of the
         candidate-path";
        uses PM-SCB-LAST-ADVERT-BAG;
      }  // container last-advertisement-information

      container next-advertisement-information {
        description
          "Current advertisement information of the
         candidate-path";
        uses PM-SCB-NEXT-ADVERT-BAG;
      }  // container next-advertisement-information

      container last-probe-results {
        description
          "Last probe results of candidate-path";
        uses PM-SCB-PROBE-RESULTS-BAG;
      }  // container last-probe-results

      container current-probe {
        description
          "Information for the current probe";
        uses PM-SCB-PROBE-BAG;
      }  // container current-probe

      container last-notification-control-code {
        description
          "Last notifcation control code received of the
         candidate-path";
        uses PM-SCB-CONTROL-CODE;
      }  // container last-notification-control-code

      container last-error-control-code {
        description
          "Last error control code received of the
         candidate-path";
        uses PM-SCB-CONTROL-CODE;
      }  // container last-error-control-code

      container liveness-detection-info {
        description
          "Information for liveness detection";
        uses PM-LIVENESS-STATE-INFO-BAG;
      }  // container liveness-detection-info

      leaf instance {
        type uint32;
        description "Session instance";
      }

      leaf preference {
        type uint32;
        description
          "Preference of the candidate-path";
      }

      leaf origin {
        type Pm-xtc-srpolicy-origin;
        description
          "Protocol-origin of the candidate-path";
      }

      leaf discriminator {
        type uint32;
        description
          "Discriminator of the candidate-path";
      }

      leaf source-address-v4 {
        type inet:ipv4-address;
        description
          "Source address of the candidate-path";
      }

      leaf reverse-path-label {
        type uint32;
        description "Reverse-path label";
      }

      leaf profile-name {
        type string;
        description
          "SR Policy delay-measurement profile name";
      }

      leaf periodic-advertisement-interval-in-sec {
        type uint32;
        units "second";
        description
          "Interval of periodic advertisement in seconds";
      }

      leaf liveness-detection-enabled {
        type boolean;
        description
          "Liveness detection is enabled";
      }

      leaf segment-list-total-count {
        type uint32;
        description
          "Number of segment lists in the candidate-path";
      }

      list segment-list {
        description "List of segment-lists";
        uses PM-SRPOLICY-SEGMENT-LIST-BAG;
      }  // list segment-list
    }  // grouping PM-SRPOLICY-CANDIDATE-PATH-BAG

    grouping PM-IP-ADDR-TYPE {
      description "IPv4/IPv6 address type";
      leaf ip-address-type {
        type Pm-addr;
        description "IPAddressType";
      }

      leaf ipv4 {
        when "../ip-address-type = 'ipv4'" {
          description
            "../IPAddressType = 'IPv4'";
        }
        type Pm-ipv4-addr;
        description "IPv4 address type";
      }

      leaf ipv6 {
        when "../ip-address-type = 'ipv6'" {
          description
            "../IPAddressType = 'IPv6'";
        }
        type Pm-ipv6-addr;
        description "IPv6 address type";
      }
    }  // grouping PM-IP-ADDR-TYPE

    grouping PM-SRPOLICY-BAG {
      description "PM SR Policy bag";
      container end-point-address {
        description
          "IPv4/IPv6 End point address";
        uses PM-IP-ADDR-TYPE;
      }  // container end-point-address

      leaf color {
        type uint32;
        description "Color";
      }

      leaf policy-name-xr {
        type string;
        description "Name of the SR Policy";
      }

      leaf candidate-path-total-count {
        type uint32;
        description
          "Number of candidate-paths in the SR Policy";
      }

      list candidate-path {
        description
          "List of candidate-paths";
        uses PM-SRPOLICY-CANDIDATE-PATH-BAG;
      }  // list candidate-path
    }  // grouping PM-SRPOLICY-BAG
  }  // submodule Cisco-IOS-XR-perf-meas-oper-sub2