module Cisco-IOS-XE-wireless-mesh-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XE-wireless-mesh-oper";

    prefix wireless-mesh-oper;

    import Cisco-IOS-XE-wireless-enum-types {
      prefix wireless-enum-types;
    }
    import Cisco-IOS-XE-wireless-types {
      prefix wireless-types;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import cisco-semver {
      prefix cisco-semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service

     Postal: 170 W Tasman Drive
     San Jose, CA 95134

     Tel: +1 1800 553-NETS

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

    description
      "Wireless Mesh Operational Data
     Copyright (c) 2016-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-07-01" {
      description
        "Added Daisy chain STP redundancy.";
      reference
        "4.3.0";

    }

    revision "2019-11-01" {
      description
        "- Deprecated started-at as it reflects real time clock. Added new leaf start-time to reflect time of the day";
      reference
        "4.2.0";

    }

    revision "2019-05-01" {
      description "Added semantic version";
      reference
        "4.1.0";

    }

    revision "2018-12-10" {
      description
        "- Update descriptions
       - Added neigh-status in st-mesh-adj-minfo
       - Added the grouping flag-neigh-status
       - Remove eth-status in st-mesh-cable-modem
       - Remove eth-speed in st-mesh-cable-modem
       - Remove node-status from st-mesh-adj-minfo
       - Remove bh-rate in st-mesh-adj-minfo
       - Remove previous-role, parent-ap-mac-addr, depth and bhaul-mask leafs from st-mesh-ap-oper-data
       - Remove the following groupings and data nodes that reference them
           - st-mesh-astools
           - st-mesh-cm-ds-rx-freq
           - st-mesh-cm-us-tx-freq
           - st-mesh-cm-us-tx-pow
           - st-mesh-cm-us-cton-ratio
           - st-mesh-hop-list
           - st-mesh-dist-vector
           - st-mesh-dist-vector-arr
           - st-mesh-smooth-snr
       - Remove leafs sys-time, east-velocity, north-velocity, up-velocity from st-mesh-gps-info
       - Remove leafs flags, worst-dist-vector, antenna, num-routes, vectors, smooth-snrs, hopcount-version, update-flag from grouping st-mesh-adj-minfo
       - Remove leafs next-channel, next-antenna, dlink-antenna, dlink-chan, current-antenna, next-neighbor from st-mesh-adj-modinfo
       - Remove adj-ancestor-list and adj-list-len from st-mesh-ap-node-neigh-info
       - Removal of unused leaves
       - Cleaned up spelling errors in descriptions
       - Added Neighbour AP's base radio MAC address in Mesh adjacent information.";
      reference
        "4.0.0";

    }

    revision "2018-05-01" {
      description
        "- Change type of bhaul-tx-rate in st-mesh-ap-oper-data from uint32 to mesh-dot11abg-data-rate
       - Added new data to st-mesh-ap-oper-data
       - Change type of data-rate in mesh-link-test-config from uint16 to mesh-linktest-rate
       - Added data-rate-index to mesh-link-test-config";
      reference
        "3.0.0";

    }

    revision "2018-01-24" {
      description
        "The first generally available version";
      reference
        "2.0.0";

    }

    revision "2017-09-25" {
      description "Initial revision";
      reference
        "1.0.0";

    }

    cisco-semver:module-version "4.3.0";
    cisco-semver:module-version "4.2.0";
    cisco-semver:module-version "4.1.0";
    cisco-semver:module-version "4.0.0";
    cisco-semver:module-version "3.0.0";
    cisco-semver:module-version "2.0.0";
    cisco-semver:module-version "1.0.0";

    typedef flag-neigh-status {
      type bits {
        bit mesh-ae-updated {
          position 0;
          description
            "Received an update for this adjacent node";
        }
        bit mesh-ae-parent {
          position 1;
          description
            "Neighbor mesh node is a parent mesh node of this mesh node";
        }
        bit mesh-ae-tent-parent {
          position 2;
          description
            "Node is the tentative parent";
        }
        bit mesh-ae-neigh {
          position 3;
          description
            "Its a neighbor mesh node. It can be on same or different mesh-sector";
        }
        bit mesh-ae-black {
          position 4;
          description "Node is blacklisted";
        }
        bit mesh-ae-hash {
          position 5;
          description
            "Whether node is on the hash table or not";
        }
        bit mesh-ae-alloc {
          position 6;
          description
            "Whether the node is allocated";
        }
        bit mesh-ae-permsnr {
          position 7;
          description
            "Management set the SNR variable";
        }
        bit mesh-ae-child {
          position 8;
          description
            "Neighbor mesh node is child of this mesh node";
        }
        bit mesh-ae-needupdate {
          position 9;
          description
            "Need an update to be considered again";
        }
        bit mesh-ae-trigger {
          position 10;
          description
            "Send trigger to parent";
        }
        bit mesh-ae-beacon {
          position 11;
          description
            "Neighbor mesh node found by passive scanning";
        }
        bit mesh-ae-default {
          position 12;
          description
            "Neighbor mesh node connected using a mismatched bridge group name";
        }
      }
      description "Mesh neighbor status";
    }

    container mesh-oper-data {
      config false;
      description "Mesh operational data";
      list mesh-q-stats {
        key "wtp-mac q-type";
        description
          "Mesh Access point packet queue statistics";
        leaf wtp-mac {
          type yang:mac-address;
          description
            "Radio MAC address common to the dot11 interface of the AP";
        }

        leaf q-type {
          type wireless-types:mesh-node-pkt-queue-type;
          description
            "Queue type on the AP radio";
        }

        leaf peak-length {
          type uint16;
          description
            "Peak number of packets waiting in the queue";
        }

        leaf average-len {
          type uint16;
          description
            "Average number of packets waiting in the queue";
        }

        leaf overflows {
          type uint16;
          description
            "Total number of packets dropped due to queue overflow";
        }
      }  // list mesh-q-stats

      list mesh-dr-stats {
        key "wtp-mac neigh-ap-mac data-rate-index";
        description
          "Mesh Access point data rate statistics";
        leaf wtp-mac {
          type yang:mac-address;
          description
            "Radio MAC address common to the dot11 interface of the AP";
        }

        leaf neigh-ap-mac {
          type yang:mac-address;
          description
            "Radio MAC address of neighbor Access Point";
        }

        leaf data-rate-index {
          type uint32;
          description
            "Supported data rates of the mesh access point";
        }

        leaf tx-success {
          type uint32;
          description
            "Total number of packets successfully transmitted at a given data rate";
        }

        leaf tx-attempts {
          type uint32;
          description
            "Total number of transmitted attempts at a given data rate";
        }
      }  // list mesh-dr-stats

      list mesh-sec-stats {
        key "wtp-mac";
        description
          "Mesh Access point security  statistics";
        leaf wtp-mac {
          type yang:mac-address;
          description
            "Radio MAC address common to the dot11 interface of the AP";
        }

        leaf tx-pkts-total {
          type uint32;
          description
            "Total number of packets transmitted by this mesh node during security negotiation";
        }

        leaf rx-pkts-total {
          type uint32;
          description
            "Total number of packets received by this mesh node during security negotiation";
        }

        leaf rx-pkts-error {
          type uint32;
          description
            "Total number of packets received with error by this mesh node during security negotiation";
        }

        container stats-parent {
          description
            "Security stats at the parent Mesh Access Point";
          leaf unknown-assoc-req {
            type uint32;
            description
              "Total number of unknown association requests received by this node, as a parent mesh node from a child mesh node";
          }

          leaf invalid-assoc-req {
            type uint32;
            description
              "Total number of invalid association requests received by this node, as a parent mesh node from a child mesh node";
          }

          leaf unknown-tgr-auth-req {
            type uint32;
            description
              "Total number of unknown TGR Auth requests received by this node, as a parent mesh node from a child mesh node";
          }

          leaf invalid-tgr-auth-req {
            type uint32;
            description
              "Total number of invalid TGR Auth requests received by this node, as a parent mesh node from a child mesh node";
          }

          leaf unknown-tgr-reassoc-req {
            type uint32;
            description
              "Total number of unknown TGR re-association requests received by this node, as a parent mesh node from a child mesh node";
          }

          leaf invalid-tgr-reassoc-req {
            type uint32;
            description
              "Total number of invalid TGR re-association requests received by this node, as a parent mesh node from a child mesh node";
          }
        }  // container stats-parent

        container stats-child {
          description
            "Security stats at the Child Mesh Access Point";
          leaf assoc-failure {
            type uint32;
            description
              "Total number of association requests sent by a child mesh node to a parent mesh node, that resulted in a failure";
          }

          leaf assoc-timeout {
            type uint32;
            description
              "Total number of association requests sent by a child mesh node to a parent mesh node, that timed out";
          }

          leaf assoc-success {
            type uint32;
            description
              "Total number of association requests sent by a child mesh node to a parent mesh node, that completed";
          }

          leaf auth-failure {
            type uint32;
            description
              "Total number of authentication requests sent by a child mesh node to a parent mesh node, that resulted in a failure";
          }

          leaf auth-timeout {
            type uint32;
            description
              "Total number of authentication requests sent by a child mesh node to a parent mesh node, that timed out";
          }

          leaf auth-success {
            type uint32;
            description
              "Total number of authentication requests sent by a child mesh node to a parent mesh node, that completed";
          }

          leaf tgr-auth-failure {
            type uint32;
            description
              "Total number of TGR authentication requests sent by a child mesh node to a parent mesh node, that resulted in a failure";
          }

          leaf tgr-auth-timeout {
            type uint32;
            description
              "Total number of TGR authentication requests sent by a child mesh node to a parent mesh node, that timed out";
          }

          leaf tgr-auth-success {
            type uint32;
            description
              "Total number of TGR authentication requests sent by a child mesh node to a parent mesh node, that completed";
          }

          leaf tgr-reassoc-failure {
            type uint32;
            description
              "Total number of TGR re-association requests sent by a child mesh node to a parent mesh node, that resulted in a failure";
          }

          leaf tgr-reassoc-timeout {
            type uint32;
            description
              "Total number of TGR re-association requests sent by a child mesh node to a parent mesh node, that timed out";
          }

          leaf tgr-reassoc-success {
            type uint32;
            description
              "Total number of TGR re-association requests sent by a child mesh node to a parent mesh node, that completed";
          }
        }  // container stats-child
      }  // list mesh-sec-stats

      list mesh-oper-data {
        key "wtp-mac";
        description
          "Mesh Access point operational data";
        leaf wtp-mac {
          type yang:mac-address;
          description
            "Radio MAC address common to the dot11 interface of the AP";
        }

        leaf bhaul-slot-id {
          type uint8;
          description
            "Backhaul Radio slot identifier used by this Access Point";
        }

        leaf bhaul-rate-mcs-ss {
          type uint8;
          description
            "Mesh Backhaul 802.11ac MCS spatial stream";
        }

        leaf active-trunk-native-vlan {
          type uint16;
          description
            "Trunk native VLAN of Mesh Access Point connected through wire";
        }

        leaf configured-role {
          type wireless-types:ap-role;
          description
            "Configured AP role for this Mesh Access Point";
        }

        leaf bhaul-radio-mode {
          type wireless-types:mesh-bhaul-mode;
          description
            "Backhaul Radio mode (11a, 11b, 11g) on this Access Point";
        }

        leaf ap-mode {
          type wireless-types:enm-ewlc-spam-ap-modes;
          description
            "AP mode for this Mesh Access Point";
        }

        leaf ap-role {
          type wireless-types:ap-role;
          description
            "AP role for this Mesh Access Point";
        }

        leaf bhaul-radio-type {
          type wireless-types:mesh-bhaul-radio-type;
          description
            "Mesh Backhaul Radio type(802.11a, 802.11bg) on this Access Point";
        }

        leaf bhaul-data-rate-type {
          type wireless-types:mesh-bhaul-data-rate-type;
          description
            "Mesh Backhaul data rate type(auto, 802.11a, 802.11bg, 11n mcs, 11ac) on this Access Point";
        }

        leaf bhaul-tx-rate {
          type wireless-types:mesh-dot11abg-data-rate;
          description
            "Data rate used in the Backhaul Radio interface of this Access Point";
        }

        leaf bhaul-rate-mcs-index {
          type uint32;
          description
            "Mesh Backhaul MCS data rate index";
        }

        leaf neigh-child-cnt {
          type uint32;
          description
            "Number of child mesh neighbours for an Access Point";
        }

        leaf ap-specific-bhaul-tx-rate {
          type boolean;
          description
            "Backhaul data rate is AP specific for this Access Point";
        }

        leaf trunk-vlan-enabled {
          type boolean;
          description
            "Whether VLAN trunking is enabled or disabled for the Root Mesh Access point";
        }

        leaf bhaul-child-presence {
          type boolean;
          description
            "If there are any child Mesh Access points present for this Mesh AP";
        }

        leaf bhaul-over-ethernet {
          type boolean;
          description
            "Whether this Mesh Access point is connected to the Controller over Ethernet interface";
        }

        leaf bgn-strict-match {
          type boolean;
          description
            "Whether Strict match of bridge group name is enabled or disabled for this Mesh Access Point";
        }

        leaf use-default-bgn {
          type boolean;
          description
            "Whether default bridge group name can be used to find a parent Mesh Access Point by this AP";
        }

        leaf daisy-chain-mode {
          type boolean;
          description
            "Whether daisy chain mode is enabled or disabled in this Mesh Access Point";
        }

        leaf rap-strict-daisy-chain-mode {
          type boolean;
          description
            "Whether strict daisy chain mode is enabled or disabled in this Mesh Access Point";
        }

        leaf block-child-enabled {
          type boolean;
          description
            "Whether child Mesh Access points are blocked to join to this Mesh Access Point";
        }

        leaf ethernet-bridging-enabled {
          type boolean;
          description
            "Whether Ethernet bridging is enabled or disabled in this Mesh Access Point";
        }

        leaf preferred-parent {
          type yang:mac-address;
          description
            "Preferred parent AP MAC Address configured on this Access Point";
        }

        leaf parent-ap-awpp-addr {
          type yang:mac-address;
          description
            "AWPP Identity at the parent Mesh Access Point";
        }

        leaf bridge-group-name {
          type string;
          description
            "Bridge group name configured on this Access Point";
        }

        leaf psk-key-timestamp {
          type string;
          description
            "Time at which this PSK key was configured";
        }

        leaf mesh-profile-configured {
          type string;
          description
            "Configured Mesh profile name for the Access Point";
        }

        leaf mesh-profile-inuse {
          type string;
          description
            "Mesh profile name used by the Access Point";
        }

        leaf daisychain-stp-redundancy {
          type boolean;
          description
            "This value indicates whether daisy chain STP redundancy is enabled or not for the Mesh Access Point";
        }
      }  // list mesh-oper-data

      list mesh-gps-info {
        key "wtp-mac";
        description
          "GPS related information for the Mesh Access point";
        leaf wtp-mac {
          type yang:mac-address;
          description
            "Radio MAC address common to the dot11 interface of the AP";
        }

        leaf location-flags {
          type uint8;
          description
            "Whether the access point has the GPS module installed or not";
        }

        leaf latitude {
          type uint32;
          description
            "Latitude information in the GPS data received";
        }

        leaf longitude {
          type uint32;
          description
            "Longitude information in the GPS data received";
        }

        leaf altitude {
          type uint32;
          description
            "Altitude information in the GPS data received";
        }
      }  // list mesh-gps-info

      list mesh-ap-node-cac-info {
        key "wtp-mac";
        description
          "Mesh call admission control related information";
        leaf wtp-mac {
          type yang:mac-address;
          description
            "Radio MAC address common to the dot11 interface of the AP";
        }

        leaf bw-in-use-24ghz {
          type uint16;
          description
            "Maximum bandwidth being utilised for 24 ghz radio";
        }

        leaf bw-in-use-5ghz {
          type uint16;
          description
            "Maximum bandwidth being utilised for 5 ghz radio";
        }

        leaf mesh-call-in-progress-24ghz {
          type uint16;
          description
            "Number of access and mesh calls in progress on radio 24 ghz";
        }

        leaf mesh-call-in-progress-5ghz {
          type uint16;
          description
            "Number of access and mesh calls in progress on radio 5 ghz";
        }

        leaf mesh-call-rejected {
          type uint16;
          description
            "Number of mesh calls rejected on backhaul radio";
        }

        leaf voice-bw-allocated-24ghz {
          type uint32;
          description
            "Voice bandwidth being allocated for 24 ghz radio";
        }

        leaf voice-bw-allocated-5ghz {
          type uint32;
          description
            "Voice bandwidth being allocated for 5 ghz radio";
        }

        list mesh-wmm-data {
          key "client-mac";
          description
            "WIFI multimedia data information";
          leaf client-mac {
            type yang:mac-address;
            description "Client MAC address";
          }

          leaf radio-type {
            type wireless-enum-types:enm-radio-type;
            description "Radio type";
          }

          leaf direction {
            type uint8;
            description
              "Data traffic direction";
          }

          leaf nominal-msdu-size {
            type uint16;
            description
              "Nominal MAC service data unit size";
          }

          leaf bw-allocated {
            type uint16;
            description
              "Bandwidth allocated for the client";
          }

          leaf mean-data-rate {
            type uint32;
            description
              "Average data rate of the radio";
          }
        }  // list mesh-wmm-data
      }  // list mesh-ap-node-cac-info

      list mesh-cm {
        key "wtp-mac";
        description
          "Cable Modem related information for the Mesh Access point";
        leaf wtp-mac {
          type yang:mac-address;
          description
            "MAC address of the Mesh Access Point";
        }

        leaf cm-mac-address {
          type yang:mac-address;
          description
            "Cable modem MAC address";
        }

        leaf ap-mac-address {
          type yang:mac-address;
          description
            "Cable modem AP MAC address";
        }

        leaf ap-cm-int-mac-address {
          type yang:mac-address;
          description
            "Mesh AP cable modem interface MAC Address";
        }

        leaf mask-bit {
          type uint32;
          description
            "Value of cable modem mask bit";
        }

        leaf cm-sw-version {
          type string;
          description
            "Cable modem software version";
        }

        leaf cm-status {
          type string;
          description
            "Docsis registration status for the cable modem interface of mesh AP";
        }

        leaf cm-serial-number {
          type string;
          description
            "Cable modem serial number";
        }
      }  // list mesh-cm

      list mesh-neigh {
        key "wtp-mac neigh-ap-mac";
        description
          "Mesh AP neighbor related information";
        leaf wtp-mac {
          type yang:mac-address;
          description
            "MAC address of the Access Point";
        }

        leaf neigh-ap-mac {
          type yang:mac-address;
          description
            "MAC address of neighbor mesh Access Point";
        }

        container mesh-neighs {
          description
            "Mesh AP neighbor details";
          leaf channel {
            type uint8;
            description
              "Channel of the neighbor Access Point";
          }

          leaf potl-parent-timeouts-left {
            type uint8;
            description
              "Remaining number of potential parent timeout";
          }

          leaf timeouts-left-for-child {
            type uint8;
            description
              "Remaining number of timeouts for the child";
          }

          leaf snr {
            type uint8;
            description
              "SNR value for the Mesh Access Point";
          }

          leaf snr-up {
            type uint8;
            description
              "SNR of the link to the AP";
          }

          leaf snr-down {
            type uint8;
            description
              "SNR of the link from the AP";
          }

          leaf link-snr {
            type uint8;
            description
              "Calculated SNR of the link";
          }

          leaf slot-id {
            type uint8;
            description
              "Radio slot id of neighbor AP";
          }

          leaf chan-width {
            type uint8;
            description
              "Channel width used by the neighbor AP";
          }

          leaf blacklist-timeouts-left {
            type uint16;
            description
              "Remaining number of blacklist timeouts";
          }

          leaf neigh-type {
            type wireless-types:enm-mesh-node-neigh-type;
            description
              "Neighbor Mesh AP's role";
          }

          leaf neigh-state {
            type wireless-types:enm-mesh-node-neigh-state;
            description
              "Neighbor Mesh AP's neighbor info update state";
          }

          leaf rate {
            type uint32;
            description
              "Current rate of the Neighbor AP";
          }

          leaf adjusted-ease {
            type uint32;
            description
              "Hops adjusted ease value";
          }

          leaf unadjusted-ease {
            type uint32;
            description
              "Ease to the root AP through this AP";
          }

          leaf rap-ease {
            type uint32;
            description
              "Unadjusted ease received in last hello message";
          }

          leaf tx-pkts-parent {
            type uint32;
            description
              "Total number of packets transmitted to this node as a parent AP";
          }

          leaf rx-pkts-parent {
            type uint32;
            description
              "Total number of packets received from this node as a parent AP";
          }

          leaf poor-snr {
            type uint32;
            description
              "Number of packets received with poor SNR";
          }

          leaf neigh-status {
            type flag-neigh-status;
            description "Neighbor status";
          }

          leaf neigh-mac-addr {
            type yang:mac-address;
            description
              "MAC address of the Neighbor AP";
          }

          leaf neigh-base-mac-addr {
            type yang:mac-address;
            description
              "Base radio MAC address of the Neighbor AP";
          }

          leaf ap-identity {
            type yang:mac-address;
            description
              "Identity of the mesh Access Point";
          }

          leaf neigh-ap-name {
            type string;
            description "Neighbor AP name";
          }

          leaf bridge-group-name {
            type string;
            description
              "Bridge group name of the neighbor AP";
          }

          leaf last-update {
            type yang:date-and-time;
            description
              "Time at which the last hello is received from this neighbor";
          }

          leaf parent-change-time {
            type yang:date-and-time;
            description
              "Time at which this AP became parent";
          }
        }  // container mesh-neighs

        container neigh-per-stats {
          description
            "Mesh AP PER statistics";
          leaf tx-pkts-total {
            type uint32;
            description
              "Total packets transmitted";
          }

          leaf tx-pkts-success {
            type uint32;
            description
              "Total packets transmitted successfully";
          }

          leaf retry-pkts-total {
            type uint32;
            description
              "Total packets retried";
          }

          leaf rts-attempts {
            type uint32;
            description
              "Number of RTS attempts";
          }

          leaf rts-success {
            type uint32;
            description
              "Number of successful RTS";
          }
        }  // container neigh-per-stats
      }  // list mesh-neigh

      list mesh-ap-neigh {
        key "wtp-mac";
        description
          "Adjacency and Ancestor information for the mesh Access Point";
        leaf wtp-mac {
          type yang:mac-address;
          description
            "MAC address of the Mesh Access Point";
        }

        container adj-modinfo {
          description
            "Adjacency information for the mesh Access Point";
          leaf rap {
            type uint8;
            description
              "Whether this is a root mode Mesh AP";
          }

          leaf current-sector-hops {
            type uint8;
            description
              "Number of hops from RAP to this mesh AP in the sector";
          }

          leaf neigh-state {
            type wireless-types:mesh-adj-state;
            description
              "Type of Neighbor Access Point";
          }

          leaf malformed-neigh-pkts {
            type uint32;
            description
              "Total number of packets received from Neighbor AP which could not be decoded";
          }

          leaf poor-neigh-snr {
            type uint32;
            description
              "Total number of packets received from Neighbor AP which has SNR value below threshold";
          }

          leaf blacklist-pkts {
            type uint32;
            description
              "Total number of packets received from excluded Neighbor APs";
          }

          leaf insufficient-memory {
            type uint32;
            description
              "Number of packets dropped due to insufficient memory";
          }

          leaf rx-neigh-req {
            type uint32;
            description
              "Total number of neighbor requests received from Neighbor APs";
          }

          leaf rx-neigh-resp {
            type uint32;
            description
              "Total number of neighbor responses received from Neighbor APs";
          }

          leaf tx-neigh-req {
            type uint32;
            description
              "Total number of neighbor requests sent to Neighbor APs";
          }

          leaf tx-neigh-resp {
            type uint32;
            description
              "Total number of neighbor responses sent to Neighbor APs";
          }

          leaf authentication-failures {
            type uint32;
            description
              "Total number of Authentication failures with Neighbor APs";
          }

          leaf parent-changes {
            type uint32;
            description
              "Total number of times this mesh node has changed its parent";
          }

          leaf neigh-timeout {
            type uint32;
            description
              "Number of Neighbor timeouts";
          }

          leaf rx-neigh-update {
            type uint32;
            description
              "Number of Neighbor updates received";
          }

          leaf tx-neigh-update {
            type uint32;
            description
              "Number of Neighbor updates transmitted";
          }

          leaf current-best-neigh {
            type uint32;
            description
              "Number of best neighbor APs";
          }
        }  // container adj-modinfo

        container dr-stats {
          description
            "Mesh AP data rate stats";
          leaf last-update {
            type uint8;
            description
              "When the neighbor table was last updated";
          }

          leaf rts-attempts {
            type uint32;
            description
              "Number of RTS attempts";
          }

          leaf rts-success {
            type uint32;
            description
              "Number of successful RTS";
          }
        }  // container dr-stats
      }  // list mesh-ap-neigh

      list mesh-subset-channel-list {
        key "bgn channel";
        description
          "Subset channel list table";
        leaf bgn {
          type string;
          description
            "Bridge group name for the access point in the mesh network";
        }

        leaf channel {
          type uint8;
          description
            "Channel number in subset channel list";
        }

        leaf rap-local-count {
          type uint8;
          description
            "Number of Root Access Points using the bridge group name and channel";
        }
      }  // list mesh-subset-channel-list

      list mesh-comp-info {
        key "wtp-mac";
        description
          "Information related to peripheral components for Mesh Access Point";
        leaf wtp-mac {
          type yang:mac-address;
          description
            "MAC address of the Access Point";
        }

        container env-info {
          description
            "Mesh AP Ethernet interface related information";
          leaf number-of-ports {
            type uint32;
            description
              "Number of Ethernet ports on the mesh AP";
          }

          leaf bhaul-intf-name {
            type string;
            description
              "Backhaul interface name for the Mesh AP";
          }

          container eth-if-status {
            description
              "Status of Mesh AP Ethernet interfaces";
            list buffer {
              max-elements 5;
              description
                "Holds the list of AP Ethernet interfaces with their status information";
              leaf intf-name {
                type string;
                description
                  "Name of the Mesh AP Ethernet Interface";
              }

              leaf port-number {
                type uint8;
                description
                  "Ethernet interface port number of the Mesh AP";
              }

              leaf speed {
                type uint8;
                description
                  "Speed for the Mesh AP Ethernet interface";
              }

              leaf duplex {
                type uint8;
                description
                  "Duplex for the Mesh AP Ethernet interface";
              }

              leaf status {
                type boolean;
                description
                  "Status of Mesh AP Ethernet interface";
              }

              container eth-stats {
                description
                  "Statistics for the Mesh AP Ethernet interface";
                leaf rx-ucast-pkts {
                  type uint32;
                  description
                    "Total number of unicast packets received on the Mesh AP Ethernet interface";
                }

                leaf rx-n-ucast-pkts {
                  type uint32;
                  description
                    "Total number of Non-unicast packets received on the Mesh AP Ethernet interface";
                }

                leaf tx-ucast-pkts {
                  type uint32;
                  description
                    "Total number of unicast packets transmitted on the Mesh AP Ethernet interface";
                }

                leaf tx-n-ucast-pkts {
                  type uint32;
                  description
                    "Total number of Non-unicast packets transmitted on the Mesh AP Ethernet interface";
                }
              }  // container eth-stats

              container eth-vlan-config {
                description
                  "VLAN configurations for Mesh AP Ethernet interface";
                container current-config {
                  description
                    "Current VLAN configurations for Mesh AP Ethernet interface";
                  leaf mode {
                    type wireless-types:ethernet-port-type;
                    description
                      "Ethernet interface mode as whether Trunk or Access";
                  }

                  leaf vlan-id {
                    type uint16;
                    description
                      "VLAN identifier for the Ethernet interface of Mesh Access Point";
                  }

                  leaf trunk-vlan-list-count {
                    type uint16;
                    description
                      "Total number of allowed VLANs for the Ethernet interface of Mesh Access Point";
                  }

                  container trunk-vlan-list {
                    description
                      "Allowed VLANs list when in trunk mode for the Mesh Access Point";
                    leaf-list buffer {
                      type uint16;
                      max-elements 16;
                      ordered-by user;
                      description
                        "Holds the list of allowed VLANs";
                    }
                  }  // container trunk-vlan-list
                }  // container current-config

                container stored-config {
                  description
                    "Stored VLAN configurations for Mesh AP Ethernet interface";
                  leaf mode {
                    type wireless-types:ethernet-port-type;
                    description
                      "Ethernet interface mode as whether Trunk or Access";
                  }

                  leaf vlan-id {
                    type uint16;
                    description
                      "VLAN identifier for the Ethernet interface of Mesh Access Point";
                  }

                  leaf trunk-vlan-list-count {
                    type uint16;
                    description
                      "Total number of allowed VLANs for the Ethernet interface of Mesh Access Point";
                  }

                  container trunk-vlan-list {
                    description
                      "Allowed VLANs list when in trunk mode for the Mesh Access Point";
                    leaf-list buffer {
                      type uint16;
                      max-elements 16;
                      ordered-by user;
                      description
                        "Holds the list of allowed VLANs";
                    }
                  }  // container trunk-vlan-list
                }  // container stored-config
              }  // container eth-vlan-config
            }  // list buffer
          }  // container eth-if-status
        }  // container env-info

        container battery-state {
          description
            "Battery related information for this mesh Access Point";
          leaf wtp-mac {
            type yang:mac-address;
            description
              "MAC address of Mesh Access Point";
          }

          leaf input-voltage {
            type uint16;
            units "volt";
            description
              "AC voltage across the input terminals of the battery in outdoor mesh Access Point";
          }

          leaf output-voltage {
            type uint16;
            units "volt";
            description
              "Voltage across the output terminals of the battery in outdoor Mesh Access Point";
          }

          leaf output-power {
            type uint16;
            units "watt";
            description
              "Output power of the battery in outdoor Mesh Access Point";
          }

          leaf internal-voltage {
            type uint16;
            units "volt";
            description
              "Internal voltage of the battery in outdoor Mesh Access Point";
          }

          leaf temperature {
            type uint16;
            units "celsius";
            description
              "Temperature in celsius of the battery in outdoor mesh Access Point";
          }

          leaf current {
            type uint16;
            units "ampere";
            description
              "Current in the Battery of outdoor Mesh Access Point";
          }

          leaf charge {
            type uint16;
            units "percentage";
            description
              "Charging status in percentage for the Battery in outdoor Mesh Access Point";
          }

          leaf alarms {
            type wireless-types:mesh-node-battery-alarm;
            description
              "Notification status for Battery related Alarms in outdoor Mesh Access Point";
          }

          leaf sw-version {
            type string;
            description
              "Software version for the Battery in outdoor Mesh Access Point";
          }

          leaf serial-number {
            type string;
            description
              "Serial number of the Battery in outdoor Mesh Access Point";
          }
        }  // container battery-state

        container peripheral-info {
          description
            "Peripheral device information for this mesh Access Point";
          container temperature {
            description
              "Temperature information of the mesh AP";
            leaf status {
              type uint32;
              description
                "Status of Mesh AP ";
            }

            leaf degree {
              type uint32;
              units "celsius";
              description
                "Degree in celsius of Mesh AP ";
            }

            leaf heater-status {
              type uint32;
              description
                "Heater status of the Mesh AP";
            }

            leaf temp-state {
              type uint32;
              description
                "Temperature state of the Mesh AP";
            }

            leaf temp-fahrenheit {
              type uint32;
              units "fahrenheit";
              description
                "Temperature info of a Mesh AP in fahrenheit";
            }
          }  // container temperature

          leaf cm-installed {
            type boolean;
            description
              "Whether cable modem is applicable for this Mesh AP";
          }

          leaf fiber-sfp-installed {
            type boolean;
            description
              "Whether Fiber SFP is applicable for this mesh AP";
          }

          leaf poe-out-status {
            type boolean;
            description
              "POE out status for this mesh AP";
          }

          leaf orientation {
            type uint8;
            description
              "Orientation for this mesh AP";
          }
        }  // container peripheral-info
      }  // list mesh-comp-info

      list mesh-linktest-parameters {
        key "linktest-id";
        description
          "Mesh linktest related information";
        leaf linktest-id {
          type uint32;
          description "Mesh linktest ID";
        }

        leaf record-in-use {
          type boolean;
          description
            "Whether the linktest is in progress";
        }

        leaf started-at {
          type yang:date-and-time;
          status deprecated;
          description
            "Time at which linktest started. Going forward, start-time should be used as started-at reflects the real time clock but not the current time of the day whereas start-time reflects current time of the day";
        }

        container config {
          description
            "Mesh linktest config parameters";
          leaf data-rate {
            type wireless-types:mesh-linktest-rate;
            description
              "Data rate in Mbps which will is supported by both APs";
          }

          leaf data-rate-index {
            type wireless-types:mesh-linktest-rate-idx;
            description
              "Data rate index used for linktest traffic";
          }

          leaf status {
            type wireless-types:mesh-linktest-cfg-status;
            description
              "Current status of the linktest";
          }

          leaf packet-size {
            type uint16;
            description
              "Size of the packets in bytes";
          }

          leaf duration {
            type uint16;
            description
              "Time interval for the linktest in seconds";
          }

          leaf pkts-per-sec {
            type uint32;
            description
              "Number of packets per seconds to be transmitted";
          }
        }  // container config

        container results {
          description
            "Mesh linktest results parameters";
          leaf elapsed-time {
            type uint32;
            description
              "Time elapsed for the Mesh Linktest";
          }

          leaf last-rx-rate {
            type uint32;
            description
              "RX rate received in the last response";
          }

          leaf link-test-buffer-allocation-error {
            type uint32;
            description
              "Number of RX buffer allocation error";
          }

          leaf link-test-queue-full-error {
            type uint32;
            description
              "Number of RX queue full error";
          }

          leaf total-tx-pkts {
            type uint32;
            description
              "Total number of packets transmitted";
          }

          leaf total-rx-pkts {
            type uint32;
            description
              "Total number of packets received";
          }

          leaf good-rx-pkts {
            type uint32;
            description
              "Total number of good packets received";
          }

          leaf duplicate-rx-pkts {
            type uint32;
            description
              "Total number of duplicate packets received";
          }

          leaf short-rx-pkts {
            type uint32;
            description
              "Total number of linktest packets which were shorter than expected";
          }

          leaf big-rx-pkts {
            type uint32;
            description
              "Total number of packets which were bigger than expected";
          }

          leaf rx-pkts-physical-errors {
            type uint32;
            description
              "Total number of packets received with error at physical layer";
          }

          leaf rx-pkts-crc-errors {
            type uint32;
            description
              "Total number of packets with CRC error";
          }

          leaf rx-pkts-seq-errors {
            type uint32;
            description
              "Total number of packets received with out of order sequence number";
          }

          leaf rx-pkts-unknown-errors {
            type uint32;
            description
              "Total number of packets received with unknown error";
          }

          leaf rx-pkts-prev-seq {
            type uint32;
            description
              "Sequence number of the last packet received";
          }

          leaf rx-pkts-lost {
            type uint32;
            description
              "Total number of packets lost during linktest";
          }

          leaf rx-pkts-average-snr {
            type int32;
            description
              "Average SNR(signal to noise) during linktest";
          }

          leaf rx-pkts-highest-snr {
            type int32;
            description
              "Highest SNR(signal to noise) during linktest";
          }

          leaf rx-pkts-lowest-snr {
            type int32;
            description
              "Lowest SNR(signal to noise) during linktest";
          }

          leaf rx-pkts-average-nf {
            type int32;
            description
              "Average NF(noise floor) during linktest";
          }

          leaf rx-pkts-highest-nf {
            type int32;
            description
              "Highest NF(noise floor) during linktest";
          }

          leaf rx-pkts-lowest-nf {
            type int32;
            description
              "Lowest NF(noise floor) during linktest";
          }

          leaf rx-pkts-average-rssi {
            type int32;
            description
              "Average RSSI during linktest";
          }

          leaf rx-pkts-highest-rssi {
            type int32;
            description
              "Highest RSSI during linktest";
          }

          leaf rx-pkts-lowest-rssi {
            type int32;
            description
              "Lowest RSSI during linktest";
          }

          leaf last-elapsed-timestamp {
            type yang:date-and-time;
            description
              "Time elapsed after the last response";
          }

          leaf last-rx-timestamp {
            type yang:date-and-time;
            description
              "Time at which the last packet was received";
          }

          container snr-profile {
            description
              "Mesh Linktest SNR Profile";
            leaf-list buffer-snr {
              type uint32;
              max-elements 21;
              ordered-by user;
              description
                "List of SNR values during the linktest";
            }
          }  // container snr-profile

          container nf-profile {
            description
              "Mesh Linktest NF Profile";
            leaf-list buffer-nf {
              type uint32;
              max-elements 21;
              ordered-by user;
              description
                "List of NF values during the linktest";
            }
          }  // container nf-profile

          container rssi-profile {
            description
              "Mesh Linktest RSSI Profile";
            leaf-list buffer-rssi {
              type uint32;
              max-elements 21;
              ordered-by user;
              description
                "List of RSSI values";
            }
          }  // container rssi-profile
        }  // container results

        leaf start-time {
          type yang:date-and-time;
          description
            "Start time of the link test";
        }

        leaf source-mac {
          type yang:mac-address;
          description
            "MAC address of the source AP";
        }

        leaf destination-mac {
          type yang:mac-address;
          description
            "MAC address of the destination AP";
        }
      }  // list mesh-linktest-parameters
    }  // container mesh-oper-data
  }  // module Cisco-IOS-XE-wireless-mesh-oper