module Cisco-IOS-XR-ppp-ma-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-ppp-ma-oper";

    prefix ppp-ma-oper;

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

    include Cisco-IOS-XR-ppp-ma-oper-sub4 {
      revision-date "2019-04-05";
    }
    include Cisco-IOS-XR-ppp-ma-oper-sub3 {
      revision-date "2019-04-05";
    }
    include Cisco-IOS-XR-ppp-ma-oper-sub2 {
      revision-date "2019-04-05";
    }
    include Cisco-IOS-XR-ppp-ma-oper-sub1 {
      revision-date "2019-04-05";
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
Customer Service

Postal: 170 West Tasman Drive
San Jose, CA 95134

Tel: +1 800 553-NETS

E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
for Cisco IOS-XR ppp-ma package operational data.

This module contains definitions
for the following management objects:
  ppp: PPP operational data

Copyright (c) 2013-2019 by Cisco Systems, Inc.
All rights reserved.";

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

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

    semver:module-version "1.0.1";

    container ppp {
      config false;
      description "PPP operational data";
      container nodes {
        description
          "Per node PPP operational data";
        list node {
          key "node-name";
          description
            "The PPP operational data for a particular node";
          container statistics {
            description
              "PPP statistics data for a particular node";
            container lcp-statistics {
              description
                "PPP LCP Statistics";
              leaf conf-req-sent {
                type uint64;
                description
                  "Conf Req Packets Sent";
              }

              leaf conf-req-rcvd {
                type uint64;
                description
                  "Conf Req Packets Received";
              }

              leaf conf-ack-sent {
                type uint64;
                description
                  "Conf Ack Packets Sent";
              }

              leaf conf-ack-rcvd {
                type uint64;
                description
                  "Conf Ack Packets Received";
              }

              leaf conf-nak-sent {
                type uint64;
                description
                  "Conf Nak Packets Sent";
              }

              leaf conf-nak-rcvd {
                type uint64;
                description
                  "Conf Nak Packets Received";
              }

              leaf conf-rej-sent {
                type uint64;
                description
                  "Conf Rej Packets Sent";
              }

              leaf conf-rej-rcvd {
                type uint64;
                description
                  "Conf Rej Packets Received";
              }

              leaf term-req-sent {
                type uint64;
                description
                  "Term Req Packets Sent";
              }

              leaf term-req-rcvd {
                type uint64;
                description
                  "Term Req Packets Received";
              }

              leaf term-ack-sent {
                type uint64;
                description
                  "Term Ack Packets Sent";
              }

              leaf term-ack-rcvd {
                type uint64;
                description
                  "Term Ack Packets Received";
              }

              leaf code-rej-sent {
                type uint64;
                description
                  "Code Rej Packets Sent";
              }

              leaf code-rej-rcvd {
                type uint64;
                description
                  "Code Rej Packets Received";
              }

              leaf proto-rej-sent {
                type uint64;
                description
                  "Proto Rej Packets Sent";
              }

              leaf proto-rej-rcvd {
                type uint64;
                description
                  "Proto Rej Packets Received";
              }

              leaf echo-req-sent {
                type uint64;
                description
                  "Echo Req Packets Sent";
              }

              leaf echo-req-rcvd {
                type uint64;
                description
                  "Echo Req Packets Received";
              }

              leaf echo-rep-sent {
                type uint64;
                description
                  "Echo Rep Packets Sent";
              }

              leaf echo-rep-rcvd {
                type uint64;
                description
                  "Echo Rep Packets Received";
              }

              leaf disc-req-sent {
                type uint64;
                description
                  "Disc Req Packets Sent";
              }

              leaf disc-req-rcvd {
                type uint64;
                description
                  "Disc Req Packets Received";
              }

              leaf link-up {
                type uint64;
                description
                  "Line Protocol Up count";
              }

              leaf link-error {
                type uint64;
                description
                  "Keepalive link failure count";
              }
            }  // container lcp-statistics

            container authentication-statistics {
              description
                "PPP Authentication statistics";
              leaf pap-req-sent {
                type uint64;
                description
                  "PAP Request packets sent";
              }

              leaf pap-req-rcvd {
                type uint64;
                description
                  "PAP Request packets received";
              }

              leaf pap-ack-sent {
                type uint64;
                description
                  "PAP Ack packets sent";
              }

              leaf pap-ack-rcvd {
                type uint64;
                description
                  "PAP Ack packets received";
              }

              leaf pap-nak-sent {
                type uint64;
                description
                  "PAP Nak packets sent";
              }

              leaf pap-nak-rcvd {
                type uint64;
                description
                  "PAP Nak packets received";
              }

              leaf chap-chall-sent {
                type uint64;
                description
                  "CHAP challenge packets sent";
              }

              leaf chap-chall-rcvd {
                type uint64;
                description
                  "CHAP challenge packets received";
              }

              leaf chap-resp-sent {
                type uint64;
                description
                  "CHAP response packets sent";
              }

              leaf chap-resp-rcvd {
                type uint64;
                description
                  "CHAP response packets received";
              }

              leaf chap-rep-succ-sent {
                type uint64;
                description
                  "CHAP reply success packets sent";
              }

              leaf chap-rep-succ-rcvd {
                type uint64;
                description
                  "CHAP reply success packets received";
              }

              leaf chap-rep-fail-sent {
                type uint64;
                description
                  "CHAP reply failure packets sent";
              }

              leaf chap-rep-fail-rcvd {
                type uint64;
                description
                  "CHAP reply failure packets received";
              }

              leaf auth-timeout-count {
                type uint64;
                description
                  "Authentication timeout count";
              }
            }  // container authentication-statistics

            list ncp-statistics-array {
              description
                "Array of PPP NCP Statistics";
              leaf ncp-identifier {
                type Ncp-ident;
                description "NCP identifier";
              }

              leaf conf-req-sent {
                type uint64;
                description
                  "Conf Req Packets Sent";
              }

              leaf conf-req-rcvd {
                type uint64;
                description
                  "Conf Req Packets Received";
              }

              leaf conf-ack-sent {
                type uint64;
                description
                  "Conf Ack Packets Sent";
              }

              leaf conf-ack-rcvd {
                type uint64;
                description
                  "Conf Ack Packets Received";
              }

              leaf conf-nak-sent {
                type uint64;
                description
                  "Conf Nak Packets Sent";
              }

              leaf conf-nak-rcvd {
                type uint64;
                description
                  "Conf Nak Packets Received";
              }

              leaf conf-rej-sent {
                type uint64;
                description
                  "Conf Rej Packets Sent";
              }

              leaf conf-rej-rcvd {
                type uint64;
                description
                  "Conf Rej Packets Received";
              }

              leaf term-req-sent {
                type uint64;
                description
                  "Term Req Packets Sent";
              }

              leaf term-req-rcvd {
                type uint64;
                description
                  "Term Req Packets Received";
              }

              leaf term-ack-sent {
                type uint64;
                description
                  "Term Ack Packets Sent";
              }

              leaf term-ack-rcvd {
                type uint64;
                description
                  "Term Ack Packets Received";
              }

              leaf proto-rej-sent {
                type uint64;
                description
                  "Proto Rej Packets Sent";
              }

              leaf proto-rej-rcvd {
                type uint64;
                description
                  "Proto Rej Packets Received";
              }
            }  // list ncp-statistics-array
          }  // container statistics

          container node-interfaces {
            description
              "Per interface PPP operational data";
            list node-interface {
              key "interface";
              description
                "LCP and summarized NCP data for an interface
running PPP";
              leaf interface {
                type xr:Interface-name;
                description
                  "Interface running PPP";
              }

              container mp-info {
                description "MP information";
                leaf is-mp-bundle {
                  type boolean;
                  description
                    "Is an MP bundle";
                }

                leaf mp-bundle-interface {
                  type xr:Interface-name;
                  description
                    "MP Bundle Interface";
                }

                leaf is-mp-bundle-member {
                  type boolean;
                  description
                    "MP Bundle Member";
                }

                leaf mp-group {
                  type uint32;
                  description "MP Group";
                }

                leaf active-links {
                  type uint16;
                  description
                    "Number of active links";
                }

                leaf inactive-links {
                  type uint16;
                  description
                    "Number of inactive links";
                }

                leaf minimum-active-links {
                  type uint16;
                  description
                    "Minimum active links required for the MPbundle
to come up";
                }

                leaf mp-state {
                  type Ppp-lcp-mp-mbr-state;
                  description "Member State";
                }

                list mp-member-info-array {
                  description
                    "Array of MP members";
                  leaf interface {
                    type xr:Interface-name;
                    description
                      "Member Interface";
                  }

                  leaf state {
                    type Ppp-lcp-mp-mbr-state;
                    description
                      "Member State";
                  }
                }  // list mp-member-info-array
              }  // container mp-info

              container configured-timeout {
                description
                  "Configured timeout";
                leaf minutes {
                  type uint32;
                  units "minute";
                  description "Minutes";
                }

                leaf seconds {
                  type uint8;
                  units "second";
                  description "Seconds";
                }
              }  // container configured-timeout

              container auth-info {
                description
                  "Authentication information";
                leaf is-authenticated {
                  type boolean;
                  description
                    "Is authenticated";
                }

                leaf is-sso-authenticated {
                  type boolean;
                  description
                    "Is SSO authenticated";
                }

                leaf of-us-auth {
                  type uint8;
                  description
                    "Of Us authentication type";
                }

                leaf of-peer-auth {
                  type uint8;
                  description
                    "Of Peer authentication type";
                }

                leaf of-us-name {
                  type string;
                  description
                    "Local authenticated name";
                }

                leaf of-peer-name {
                  type string;
                  description
                    "Peer's authenticated name";
                }

                leaf of-us-sso-state {
                  type Ppp-sso-fsm-state;
                  description
                    "Of Us auth SSO FSM State";
                }

                leaf of-peer-sso-state {
                  type Ppp-sso-fsm-state;
                  description
                    "Of Peer auth SSO FSM State";
                }
              }  // container auth-info

              leaf parent-state {
                type Im-state;
                description "Parent state";
              }

              leaf line-state {
                type Im-state;
                description "Line state";
              }

              leaf is-loopback-detected {
                type boolean;
                description
                  "Loopback detected";
              }

              leaf caps-idb-srg-role {
                type uint32;
                description
                  "Caps IDB SRG role";
              }

              leaf session-srg-role {
                type uint32;
                description
                  "Session SRG role";
              }

              leaf keepalive-period {
                type uint32;
                description
                  "Keepalive value";
              }

              leaf keepalive-retry-count {
                type uint32;
                description
                  "Keepalive retry count";
              }

              leaf is-ssrp-configured {
                type boolean;
                description
                  "Is SSRP configured";
              }

              leaf is-l2ac {
                type boolean;
                description "Is L2 AC";
              }

              leaf provisioned {
                type boolean;
                description "Provisioned";
              }

              leaf ip-interworking-enabled {
                type boolean;
                description
                  "IP Interworking Enabled";
              }

              leaf xconnect-id {
                type uint32;
                description "XConnect ID";
              }

              leaf is-tunneled-session {
                type boolean;
                description
                  "Is tunneled session";
              }

              leaf ssrp-peer-id {
                type string;
                description "SSRP Peer ID";
              }

              leaf lcp-state {
                type Ppp-fsm-state;
                description
                  "PPP/LCP state value";
              }

              leaf lcpsso-state {
                type Ppp-sso-fsm-state;
                description "LCP SSO state";
              }

              leaf is-lcp-delayed {
                type boolean;
                description "Is LCP Delayed";
              }

              leaf local-mru {
                type uint16;
                description "Local MRU";
              }

              leaf peer-mru {
                type uint16;
                description "Peer MRU";
              }

              leaf local-mrru {
                type uint16;
                description "Local MRRU";
              }

              leaf peer-mrru {
                type uint16;
                description "Peer MRRU";
              }

              leaf local-ed {
                type string {
                  length "0..41";
                }
                description
                  "Local Endpt Discriminator";
              }

              leaf peer-ed {
                type string {
                  length "0..41";
                }
                description
                  "Peer Endpt Discriminator";
              }

              leaf is-mcmp-enabled {
                type boolean;
                description
                  "Is MCMP enabled";
              }

              leaf local-mcmp-classes {
                type uint8;
                description
                  "Local MCMP classes";
              }

              leaf peer-mcmp-classes {
                type uint8;
                description
                  "Peer MCMP classes";
              }

              leaf session-expires {
                type uint32;
                units "second";
                description
                  "Session expiry time in seconds since 00:00:00 on
January 1, 1970, UTC.";
              }

              list ncp-info-array {
                description
                  "Array of per-NCP data";
                container ncp-info {
                  description
                    "Specific NCP info";
                  container ipcp-info {
                    when "../type = 'ipcp'" {
                      description
                        "../Type = 'IPCP'";
                    }
                    description
                      "Info for IPCP";
                    container local-iphc-options {
                      description
                        "Local IPHC options";
                      leaf compression-type {
                        type Ppp-iphc-compression;
                        description
                          "Compression type";
                      }

                      leaf tcp-space {
                        type uint16;
                        description
                          "TCP space";
                      }

                      leaf non-tcp-space {
                        type uint16;
                        description
                          "Non-TCP space";
                      }

                      leaf max-period {
                        type uint16;
                        description
                          "Max period";
                      }

                      leaf max-time {
                        type uint16;
                        description
                          "Max time";
                      }

                      leaf max-header {
                        type uint16;
                        description
                          "Max header";
                      }

                      leaf rtp-compression {
                        type boolean;
                        description
                          "RTP compression";
                      }

                      leaf ec-rtp-compression {
                        type boolean;
                        description
                          "EcRTP compression";
                      }
                    }  // container local-iphc-options

                    container peer-iphc-options {
                      description
                        "Peer IPHC options";
                      leaf compression-type {
                        type Ppp-iphc-compression;
                        description
                          "Compression type";
                      }

                      leaf tcp-space {
                        type uint16;
                        description
                          "TCP space";
                      }

                      leaf non-tcp-space {
                        type uint16;
                        description
                          "Non-TCP space";
                      }

                      leaf max-period {
                        type uint16;
                        description
                          "Max period";
                      }

                      leaf max-time {
                        type uint16;
                        description
                          "Max time";
                      }

                      leaf max-header {
                        type uint16;
                        description
                          "Max header";
                      }

                      leaf rtp-compression {
                        type boolean;
                        description
                          "RTP compression";
                      }

                      leaf ec-rtp-compression {
                        type boolean;
                        description
                          "EcRTP compression";
                      }
                    }  // container peer-iphc-options

                    leaf local-address {
                      type inet:ipv4-address;
                      description
                        "Local IPv4 address";
                    }

                    leaf peer-address {
                      type inet:ipv4-address;
                      description
                        "Peer IPv4 address";
                    }

                    leaf peer-netmask {
                      type inet:ipv4-address;
                      description
                        "Peer IPv4 netmask";
                    }

                    leaf dns-primary {
                      type inet:ipv4-address;
                      description
                        "Peer DNS Primary";
                    }

                    leaf dns-secondary {
                      type inet:ipv4-address;
                      description
                        "Peer DNS Secondary";
                    }

                    leaf wins-primary {
                      type inet:ipv4-address;
                      description
                        "Peer WINS Primary";
                    }

                    leaf wins-secondary {
                      type inet:ipv4-address;
                      description
                        "Peer WINS Secondary";
                    }

                    leaf is-iphc-configured {
                      type boolean;
                      description
                        "Is IPHC Configured";
                    }
                  }  // container ipcp-info

                  container ipcpiw-info {
                    when
                      "../type = 'ipcpiw'" {
                      description
                        "../Type = 'IPCPIW'";
                    }
                    description
                      "Info for IPCPIW";
                    leaf local-address {
                      type inet:ipv4-address;
                      description
                        "Local IPv4 address";
                    }

                    leaf peer-address {
                      type inet:ipv4-address;
                      description
                        "Peer IPv4 address";
                    }
                  }  // container ipcpiw-info

                  container ipv6cp-info {
                    when
                      "../type = 'ipv6cp'" {
                      description
                        "../Type = 'IPV6CP'";
                    }
                    description
                      "Info for IPv6CP";
                    leaf local-address {
                      type inet:ipv6-address;
                      description
                        "Local IPv6 address";
                    }

                    leaf peer-address {
                      type inet:ipv6-address;
                      description
                        "Peer IPv6 address";
                    }
                  }  // container ipv6cp-info

                  leaf type {
                    type Ncp-ident;
                    description "Type";
                  }
                }  // container ncp-info

                leaf ncp-state {
                  type Ppp-fsm-state;
                  description
                    "NCP state value";
                }

                leaf ncpsso-state {
                  type Ppp-sso-fsm-state;
                  description
                    "NCP SSO State";
                }

                leaf is-passive {
                  type boolean;
                  description "Is Passive";
                }

                leaf ncp-identifier {
                  type Ncp-ident;
                  description
                    "NCP state identifier";
                }
              }  // list ncp-info-array
            }  // list node-interface
          }  // container node-interfaces

          container sso-alerts {
            description
              "PPP SSO Alert data for a particular node";
            list sso-alert {
              key "interface";
              description
                "PPP SSO Alert data for a particular interface";
              leaf interface {
                type xr:Interface-name;
                description
                  "Interface with SSO Alert";
              }

              container lcp-error {
                description "LCP SSO Error";
                leaf is-error {
                  type boolean;
                  description "Is SSO Error";
                }

                leaf error {
                  type uint32;
                  description "SSO Error";
                }

                leaf context {
                  type uint32;
                  description "Context";
                }
              }  // container lcp-error

              container of-us-auth-error {
                description
                  "Of-us Authentication SSO Error";
                leaf is-error {
                  type boolean;
                  description "Is SSO Error";
                }

                leaf error {
                  type uint32;
                  description "SSO Error";
                }

                leaf context {
                  type uint32;
                  description "Context";
                }
              }  // container of-us-auth-error

              container of-peer-auth-error {
                description
                  "Of-peer Authentication SSO Error";
                leaf is-error {
                  type boolean;
                  description "Is SSO Error";
                }

                leaf error {
                  type uint32;
                  description "SSO Error";
                }

                leaf context {
                  type uint32;
                  description "Context";
                }
              }  // container of-peer-auth-error

              container ipcp-error {
                description "IPCP SSO Error";
                leaf is-error {
                  type boolean;
                  description "Is SSO Error";
                }

                leaf error {
                  type uint32;
                  description "SSO Error";
                }

                leaf context {
                  type uint32;
                  description "Context";
                }
              }  // container ipcp-error
            }  // list sso-alert
          }  // container sso-alerts

          container node-interface-statistics {
            description
              "Per interface PPP operational statistics";
            list node-interface-statistic {
              key "interface-name";
              description
                "LCP and NCP statistics for an interface
running PPP";
              leaf interface-name {
                type xr:Interface-name;
                description
                  "Interface running PPP";
              }

              container lcp-statistics {
                description
                  "PPP LCP Statistics";
                leaf conf-req-sent {
                  type uint16;
                  description
                    "Conf Req Packets Sent";
                }

                leaf conf-req-rcvd {
                  type uint16;
                  description
                    "Conf Req Packets Received";
                }

                leaf conf-ack-sent {
                  type uint16;
                  description
                    "Conf Ack Packets Sent";
                }

                leaf conf-ack-rcvd {
                  type uint16;
                  description
                    "Conf Ack Packets Received";
                }

                leaf conf-nak-sent {
                  type uint16;
                  description
                    "Conf Nak Packets Sent";
                }

                leaf conf-nak-rcvd {
                  type uint16;
                  description
                    "Conf Nak Packets Received";
                }

                leaf conf-rej-sent {
                  type uint16;
                  description
                    "Conf Rej Packets Sent";
                }

                leaf conf-rej-rcvd {
                  type uint16;
                  description
                    "Conf Rej Packets Received";
                }

                leaf echo-req-sent {
                  type uint16;
                  description
                    "Echo Req Packets Sent";
                }

                leaf echo-req-rcvd {
                  type uint16;
                  description
                    "Echo Req Packets Received";
                }

                leaf echo-rep-sent {
                  type uint16;
                  description
                    "Echo Rep Packets Sent";
                }

                leaf echo-rep-rcvd {
                  type uint16;
                  description
                    "Echo Rep Packets Received";
                }

                leaf disc-req-sent {
                  type uint16;
                  description
                    "Disc Req Packets Sent";
                }

                leaf disc-req-rcvd {
                  type uint16;
                  description
                    "Disc Req Packets Received";
                }

                leaf link-up {
                  type uint16;
                  description
                    "Line Protocol Up count";
                }

                leaf link-error {
                  type uint16;
                  description
                    "Keepalive link failure count";
                }
              }  // container lcp-statistics

              container authentication-statistics {
                description
                  "PPP Authentication statistics";
                leaf pap-req-sent {
                  type uint16;
                  description
                    "PAP Request packets sent";
                }

                leaf pap-req-rcvd {
                  type uint16;
                  description
                    "PAP Request packets received";
                }

                leaf pap-ack-sent {
                  type uint16;
                  description
                    "PAP Ack packets sent";
                }

                leaf pap-ack-rcvd {
                  type uint16;
                  description
                    "PAP Ack packets received";
                }

                leaf pap-nak-sent {
                  type uint16;
                  description
                    "PAP Nak packets sent";
                }

                leaf pap-nak-rcvd {
                  type uint16;
                  description
                    "PAP Nak packets received";
                }

                leaf chap-chall-sent {
                  type uint16;
                  description
                    "CHAP challenge packets sent";
                }

                leaf chap-chall-rcvd {
                  type uint16;
                  description
                    "CHAP challenge packets received";
                }

                leaf chap-resp-sent {
                  type uint16;
                  description
                    "CHAP response packets sent";
                }

                leaf chap-resp-rcvd {
                  type uint16;
                  description
                    "CHAP response packets received";
                }

                leaf chap-rep-succ-sent {
                  type uint16;
                  description
                    "CHAP reply success packets sent";
                }

                leaf chap-rep-succ-rcvd {
                  type uint16;
                  description
                    "CHAP reply success packets received";
                }

                leaf chap-rep-fail-sent {
                  type uint16;
                  description
                    "CHAP reply failure packets sent";
                }

                leaf chap-rep-fail-rcvd {
                  type uint16;
                  description
                    "CHAP reply failure packets received";
                }

                leaf auth-timeout-count {
                  type uint16;
                  description
                    "Authentication timeout count";
                }
              }  // container authentication-statistics

              list ncp-statistics-array {
                description
                  "Array of PPP NCP Statistics";
                leaf ncp-identifier {
                  type Ncp-ident;
                  description
                    "NCP identifier";
                }

                leaf conf-req-sent {
                  type uint16;
                  description
                    "Conf Req Packets Sent";
                }

                leaf conf-req-rcvd {
                  type uint16;
                  description
                    "Conf Req Packets Received";
                }

                leaf conf-ack-sent {
                  type uint16;
                  description
                    "Conf Ack Packets Sent";
                }

                leaf conf-ack-rcvd {
                  type uint16;
                  description
                    "Conf Ack Packets Received";
                }

                leaf conf-nak-sent {
                  type uint16;
                  description
                    "Conf Nak Packets Sent";
                }

                leaf conf-nak-rcvd {
                  type uint16;
                  description
                    "Conf Nak Packets Received";
                }

                leaf conf-rej-sent {
                  type uint16;
                  description
                    "Conf Rej Packets Sent";
                }

                leaf conf-rej-rcvd {
                  type uint16;
                  description
                    "Conf Rej Packets Received";
                }
              }  // list ncp-statistics-array
            }  // list node-interface-statistic
          }  // container node-interface-statistics

          container sso-summary {
            description
              "Summarized PPP SSO data for a particular node";
            container lcp-states {
              description
                "LCP SSO FSM States";
              leaf total {
                type uint16;
                description
                  "Total number of SSO FSMs running";
              }

              leaf-list count {
                type uint16;
                max-elements 8;
                description
                  "Number of SSO FSMs in each State";
              }
            }  // container lcp-states

            container of-us-auth-states {
              description
                "Of-us Authentication SSO FSM States";
              leaf total {
                type uint16;
                description
                  "Total number of SSO FSMs running";
              }

              leaf-list count {
                type uint16;
                max-elements 8;
                description
                  "Number of SSO FSMs in each State";
              }
            }  // container of-us-auth-states

            container of-peer-auth-states {
              description
                "Of-peer Authentication SSO FSM States";
              leaf total {
                type uint16;
                description
                  "Total number of SSO FSMs running";
              }

              leaf-list count {
                type uint16;
                max-elements 8;
                description
                  "Number of SSO FSMs in each State";
              }
            }  // container of-peer-auth-states

            container ipcp-states {
              description
                "IPCP SSO FSM States";
              leaf total {
                type uint16;
                description
                  "Total number of SSO FSMs running";
              }

              leaf-list count {
                type uint16;
                max-elements 8;
                description
                  "Number of SSO FSMs in each State";
              }
            }  // container ipcp-states
          }  // container sso-summary

          container sso-groups {
            description
              "PPP SSO Group data for a particular node";
            list sso-group {
              key "group-id";
              description
                "PPP SSO state data for a particular group";
              container sso-states {
                description
                  "PPP SSO State data for a particular group";
                list sso-state {
                  key "session-id";
                  description
                    "PPP SSO State data for a particular
interface";
                  leaf session-id {
                    type uint32 {
                      range "1..4294967295";
                    }
                    description
                      "Session ID for the interface with SSO
State";
                  }

                  container lcp-state {
                    description
                      "LCP SSO State";
                    leaf is-running {
                      type boolean;
                      description
                        "Is SSO FSM Running";
                    }

                    leaf state {
                      type Ppp-sso-fsm-state;
                      description
                        "SSO FSM State";
                    }
                  }  // container lcp-state

                  container of-us-auth-state {
                    description
                      "Of-us Authentication SSO State";
                    leaf is-running {
                      type boolean;
                      description
                        "Is SSO FSM Running";
                    }

                    leaf state {
                      type Ppp-sso-fsm-state;
                      description
                        "SSO FSM State";
                    }
                  }  // container of-us-auth-state

                  container of-peer-auth-state {
                    description
                      "Of-peer Authentication SSO State";
                    leaf is-running {
                      type boolean;
                      description
                        "Is SSO FSM Running";
                    }

                    leaf state {
                      type Ppp-sso-fsm-state;
                      description
                        "SSO FSM State";
                    }
                  }  // container of-peer-auth-state

                  container ipcp-state {
                    description
                      "IPCP SSO State";
                    leaf is-running {
                      type boolean;
                      description
                        "Is SSO FSM Running";
                    }

                    leaf state {
                      type Ppp-sso-fsm-state;
                      description
                        "SSO FSM State";
                    }
                  }  // container ipcp-state

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

                  leaf interface {
                    type xr:Interface-name;
                    description "Interface";
                  }
                }  // list sso-state
              }  // container sso-states

              leaf group-id {
                type uint32 {
                  range "1..65535";
                }
                description
                  "The identifier for the group";
              }
            }  // list sso-group
          }  // container sso-groups

          container summary {
            description
              "Summarized PPP data for a particular node";
            container intfs {
              description
                "Interfaces running PPP";
              leaf pos-count {
                type uint32;
                description "POS Count";
              }

              leaf serial-count {
                type uint32;
                description "Serial Count";
              }

              leaf pppoe-count {
                type uint32;
                description "PPPoE Count";
              }

              leaf multilink-bundle-count {
                type uint32;
                description
                  "Multilink Bundle Count";
              }

              leaf gcc0-count {
                type uint32;
                description "GCC0 Count";
              }

              leaf gcc1-count {
                type uint32;
                description "GCC1 Count";
              }

              leaf gcc2-count {
                type uint32;
                description "GCC2 Count";
              }

              leaf total {
                type uint32;
                description "Total Count";
              }
            }  // container intfs

            container fsm-states {
              description "FSM States";
              container lcpfsm-states {
                description
                  "Array of per-LCP FSM States";
                leaf total {
                  type uint32;
                  description
                    "Total number of LCP FSMs running";
                }

                leaf-list count {
                  type uint32;
                  max-elements 10;
                  description
                    "Number of FSMs in each State";
                }
              }  // container lcpfsm-states

              list ncpfsm-states-array {
                description
                  "Array of per-NCP FSM States";
                leaf ncp-identifier {
                  type Ncp-ident;
                  description
                    "NCP Identifier";
                }

                leaf total {
                  type uint32;
                  description
                    "Total number of FSMs running for this NCP";
                }

                leaf-list count {
                  type uint32;
                  max-elements 10;
                  description
                    "Number of FSMs in each State";
                }
              }  // list ncpfsm-states-array
            }  // container fsm-states

            container lcp-auth-phases {
              description "LCP/Auth Phases";
              leaf lcp-not-negotiated {
                type uint32;
                description
                  "Number of sessions with LCP not negotiated";
              }

              leaf authenticating {
                type uint32;
                description
                  "Number of sessions authenticating";
              }

              leaf line-held-down {
                type uint32;
                description
                  "Number of sessions negotiated but with the line
held down";
              }

              leaf up-local-term {
                type uint32;
                description
                  "Number of locally terminated sessions brought up";
              }

              leaf up-l2-fwded {
                type uint32;
                description
                  "Number of L2 forwarded sessions brought up";
              }

              leaf up-tunneled {
                type uint32;
                description
                  "Number of VPDN tunneled sessions brought up";
              }
            }  // container lcp-auth-phases
          }  // container summary

          leaf node-name {
            type xr:Node-id;
            description
              "The identifier for the node";
          }
        }  // list node
      }  // container nodes
    }  // container ppp
  }  // module Cisco-IOS-XR-ppp-ma-oper