module Cisco-IOS-XR-sysadmin-controllers-asr9k {

    yang-version 1;

    namespace
      "http://www.cisco.com/ns/yang/Cisco-IOS-XR-sysadmin-controllers-ASR9K";

    prefix calvados_controllers_asr9k;

    import Cisco-IOS-XR-sysadmin-ethsw-esdma-cli-asr9k {
      prefix esdma;
    }
    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems Inc.";

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

    description
      "This module contains a collection of YANG
     definitions for Cisco IOS-XR SysAdmin configuration.
     
     This module defines the top level container for
     all hardware devices managed in Sysadmin.
     
     Copyright (c) 2011-2020 by Cisco Systems, Inc.
     All rights reserved.";

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

    revision "2017-11-10" {
      description
        "Changed the namespace for ASR9K platform";
    }

    revision "2017-01-31" {
      description
        "Changed the namespace and module name";
    }

    revision "2015-02-23" {
      description "Initial Revision";
    }

    semver:module-version "1.0.0";

    container controller {
      container switch {
        container oper {
          config false;
          description
            "Control Ethernet switch operational data.";
          container reachable {
            list location {
              key "rack card switch-id";
              leaf rack {
                type esdma_types:esdma-rack-num-enum;
              }

              leaf card {
                type esdma_types:esdma-cpu;
              }

              leaf switch-id {
                type esdma_types:esdma-switch-type-enum;
              }
            }  // list location
          }  // container reachable

          container summary {
            list location {
              key "rack card switch-id";
              leaf rack {
                type esdma_types:esdma-rack-num-enum;
              }

              leaf card {
                type esdma_types:esdma-cpu;
                description
                  "Card that owns a switch of interest";
              }

              leaf switch-id {
                type esdma_types:esdma-switch-type-enum;
                description "Switch type";
              }

              leaf serial-num {
                type string;
                description
                  "Rack serial number";
              }

              list port-iter {
                key "port";
                leaf port {
                  type esdma_types:esdma-switch-port-type;
                  description "Switch port";
                }

                leaf phys-state {
                  type esdma_types:esdma-switch-port-state;
                  description
                    "Physical port state";
                }

                leaf admin-state {
                  type esdma_types:esdma-switch-port-state;
                  description
                    "Administrative port state";
                }

                leaf port-speed {
                  type string;
                  description
                    "Indicates the port speed in bits per second";
                }

                leaf protocol-state {
                  type esdma_types:mlap-state-enum;
                  description
                    "Protocol invoked port state";
                }

                leaf forwarding {
                  type esdma_types:switch-forwarding-state;
                  description
                    "Indicates whether this port is allowed to forward traffic";
                }

                leaf connects-to {
                  type string;
                  description
                    "Indicates what this port connects to";
                }
              }  // list port-iter
            }  // list location
          }  // container summary

          container statistics {
            container summary-statistics {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                  description
                    "Card that owns a switch of interest";
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                  description "Switch type";
                }

                leaf serial-num {
                  type string;
                  description
                    "Rack serial number";
                }

                list port-iter {
                  key "port";
                  leaf port {
                    type esdma_types:esdma-switch-port-type;
                    description
                      "Switch port";
                  }

                  leaf phys-state {
                    type esdma_types:esdma-switch-port-state;
                    description
                      "Physical port state";
                  }

                  leaf state-changes {
                    type uint32;
                    description
                      "Physical port state changes";
                  }

                  leaf sw-sum-tx-packets {
                    type uint64;
                    description
                      "Packets transmitted on this switch port";
                  }

                  leaf sw-sum-rx-packets {
                    type uint64;
                    description
                      "Indicates the port speed in bits per second";
                  }

                  leaf sw-sum-tx-drops-errors {
                    type uint64;
                    description
                      "Indicates the number of transmitted packets that had an error or were dropped by the policer";
                  }

                  leaf sw-sum-rx-drops-errors {
                    type uint64;
                    description
                      "Indicates the number of received packets that had an error or were dropped by the policer";
                  }

                  leaf connects-to {
                    type string;
                    description
                      "Indicates what this port connects to";
                  }
                }  // list port-iter
              }  // list location
            }  // container summary-statistics

            container detail {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                  description
                    "Card that owns a switch of interest";
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                  description "Switch type";
                }

                list port-iter {
                  key "port";
                  leaf port {
                    type esdma_types:esdma-switch-port-type;
                    description
                      "Switch port";
                  }

                  leaf phys-state {
                    type esdma_types:esdma-switch-port-state;
                    description
                      "Physical port state";
                  }

                  leaf port-speed {
                    type string;
                    description
                      "Indicates the port speed in bits per second";
                  }

                  leaf connects-to {
                    type string;
                    description
                      "Indicates what this port connects to";
                  }

                  container counters {
                    leaf sw-det-rx-ucast-packets {
                      type uint64;
                    }

                    leaf sw-det-rx-mcast-packets {
                      type uint64;
                    }

                    leaf sw-det-rx-bcast-packets {
                      type uint64;
                    }

                    leaf sw-det-rx-flow-control {
                      type uint64;
                    }

                    leaf sw-det-rx-good-octets {
                      type uint64;
                    }

                    leaf sw-det-rx-bad-octets {
                      type uint64;
                    }

                    leaf sw-det-rx-fifo-overrun {
                      type uint64;
                    }

                    leaf sw-det-rx-undersize {
                      type uint64;
                    }

                    leaf sw-det-rx-fragments {
                      type uint64;
                    }

                    leaf sw-det-rx-oversize {
                      type uint64;
                    }

                    leaf sw-det-rx-jabber {
                      type uint64;
                    }

                    leaf sw-det-rx-errors {
                      type uint64;
                    }

                    leaf sw-det-rx-bad-crc {
                      type uint64;
                    }

                    leaf sw-det-rx-collisions {
                      type uint64;
                    }

                    leaf sw-det-rx-policing-drops {
                      type uint64;
                    }

                    leaf sw-det-tx-ucast-packets {
                      type uint64;
                    }

                    leaf sw-det-tx-mcast-packets {
                      type uint64;
                    }

                    leaf sw-det-tx-bcast-packets {
                      type uint64;
                    }

                    leaf sw-det-tx-flow-control {
                      type uint64;
                    }

                    leaf sw-det-tx-good-octets {
                      type uint64;
                    }

                    leaf sw-det-tx-deferred {
                      type uint64;
                    }

                    leaf sw-det-tx-fifo-unrun {
                      type uint64;
                    }

                    leaf sw-det-tx-mult-collision {
                      type uint64;
                    }

                    leaf sw-det-tx-excess-collision {
                      type uint64;
                    }

                    leaf sw-det-tx-late-collisions {
                      type uint64;
                    }

                    leaf sw-det-tx-policing-drops {
                      type uint64;
                    }

                    leaf sw-det-txq-drops {
                      type uint64;
                    }

                    leaf sw-det-rxtx-packets-64 {
                      type uint64;
                    }

                    leaf sw-det-rxtx-packets-65-127 {
                      type uint64;
                    }

                    leaf sw-det-rxtx-packets-128-255 {
                      type uint64;
                    }

                    leaf sw-det-rxtx-packets-256-511 {
                      type uint64;
                    }

                    leaf sw-det-rxtx-packets-512-1023 {
                      type uint64;
                    }

                    leaf sw-det-rxtx-packets-1024-max {
                      type uint64;
                    }
                  }  // container counters
                }  // list port-iter
              }  // list location
            }  // container detail
          }  // container statistics

          container mac {
            container mac-statistics {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                  description
                    "Card to list the switch MAC information for";
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                  description "Switch type";
                }

                list port-iter {
                  key "port";
                  leaf port {
                    type esdma_types:esdma-switch-port-type;
                    description
                      "Switch port";
                  }

                  list mac-entry {
                    key "id";
                    leaf id {
                      type uint32;
                    }

                    leaf base-reg {
                      type string;
                    }

                    leaf desc {
                      type string;
                    }

                    leaf value {
                      type string;
                    }
                  }  // list mac-entry
                }  // list port-iter
              }  // list location
            }  // container mac-statistics
          }  // container mac

          container bridge {
            container statistics {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                  description "Card";
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                  description "Switch type";
                }

                list ingress-set-id {
                  key "ingress-set";
                  leaf ingress-set {
                    type uint32;
                  }

                  leaf ingress-set-name {
                    type string;
                  }

                  leaf ingress-frames {
                    type uint64;
                  }

                  leaf ingress-vlan-discards {
                    type uint64;
                  }

                  leaf ingress-security-discards {
                    type uint64;
                  }

                  leaf ingress-other-discards {
                    type uint64;
                  }
                }  // list ingress-set-id

                list egress-set-id {
                  key "egress-set";
                  leaf egress-set {
                    type uint32;
                  }

                  leaf egress-set-name {
                    type string;
                  }

                  leaf egress-ucast-frames {
                    type uint64;
                  }

                  leaf egress-mcast-frames {
                    type uint64;
                  }

                  leaf egress-bcast-frames {
                    type uint64;
                  }

                  leaf egress-discarded-frames {
                    type uint64;
                  }

                  leaf egress-txq-congestion {
                    type uint64;
                  }

                  leaf egress-ctrl-packets {
                    type uint64;
                  }

                  leaf egress-other-drops {
                    type uint64;
                  }
                }  // list egress-set-id
              }  // list location
            }  // container statistics
          }  // container bridge

          container fdb {
            container vlan {
              list vlan-iter {
                key "vlan";
                leaf vlan {
                  type esdma_types:vlan-id-type;
                }

                container switch-fdb-common {
                  list location {
                    key "rack card switch-id";
                    leaf rack {
                      type esdma_types:esdma-rack-num-enum;
                    }

                    leaf card {
                      type esdma_types:esdma-cpu;
                      description
                        "Card to list the switch FDB information for";
                    }

                    leaf switch-id {
                      type esdma_types:esdma-switch-type-enum;
                      description
                        "Switch type";
                    }

                    leaf num-entries {
                      type uint32;
                      description
                        "Number of FDB entries in the table.";
                    }

                    leaf has-trunk-entry {
                      type uint8;
                      description
                        "FDB entries contain an entry from the trunk";
                    }

                    leaf trunk-entry-message {
                      type string;
                      description
                        "Message displayed when an FDB entry contains an entry for a trunk member port";
                    }

                    container fdb-block {
                      list fdb-entry {
                        key "fdb-index";
                        leaf fdb-index {
                          type uint32;
                        }

                        leaf fdb-mac-addr {
                          type ietf:mac-address;
                        }

                        leaf fdb-vlan {
                          type esdma_types:vlan-id-type;
                        }

                        leaf fdb-vlan-hex {
                          type leafref {
                            path "../fdb-vlan";
                          }
                        }

                        leaf fdb-port {
                          type esdma_types:esdma-switch-fdb-ports;
                          description
                            "Switch port MAC address learned on.";
                        }

                        leaf fdb-trap-entry {
                          type esdma_types:esdma-switch-yes-no-enum;
                        }

                        leaf fdb-static-entry {
                          type esdma_types:esdma-switch-yes-no-enum;
                        }

                        leaf-list fdb-synced-cores {
                          type uint8;
                        }
                      }  // list fdb-entry
                    }  // container fdb-block
                  }  // list location
                }  // container switch-fdb-common
              }  // list vlan-iter
            }  // container vlan

            container mac {
              list mac-iter {
                key "mac";
                leaf mac {
                  type ietf:mac-address;
                }

                container switch-fdb-common {
                  list location {
                    key "rack card switch-id";
                    leaf rack {
                      type esdma_types:esdma-rack-num-enum;
                    }

                    leaf card {
                      type esdma_types:esdma-cpu;
                      description
                        "Card to list the switch FDB information for";
                    }

                    leaf switch-id {
                      type esdma_types:esdma-switch-type-enum;
                      description
                        "Switch type";
                    }

                    leaf num-entries {
                      type uint32;
                      description
                        "Number of FDB entries in the table.";
                    }

                    leaf has-trunk-entry {
                      type uint8;
                      description
                        "FDB entries contain an entry from the trunk";
                    }

                    leaf trunk-entry-message {
                      type string;
                      description
                        "Message displayed when an FDB entry contains an entry for a trunk member port";
                    }

                    container fdb-block {
                      list fdb-entry {
                        key "fdb-index";
                        leaf fdb-index {
                          type uint32;
                        }

                        leaf fdb-mac-addr {
                          type ietf:mac-address;
                        }

                        leaf fdb-vlan {
                          type esdma_types:vlan-id-type;
                        }

                        leaf fdb-vlan-hex {
                          type leafref {
                            path "../fdb-vlan";
                          }
                        }

                        leaf fdb-port {
                          type esdma_types:esdma-switch-fdb-ports;
                          description
                            "Switch port MAC address learned on.";
                        }

                        leaf fdb-trap-entry {
                          type esdma_types:esdma-switch-yes-no-enum;
                        }

                        leaf fdb-static-entry {
                          type esdma_types:esdma-switch-yes-no-enum;
                        }

                        leaf-list fdb-synced-cores {
                          type uint8;
                        }
                      }  // list fdb-entry
                    }  // container fdb-block
                  }  // list location
                }  // container switch-fdb-common
              }  // list mac-iter
            }  // container mac

            container port {
              list port-iter {
                key "port";
                leaf port {
                  type esdma_types:esdma-switch-port-type;
                  description
                    "Switch port used for filtering";
                }

                container switch-fdb-common {
                  list location {
                    key "rack card switch-id";
                    leaf rack {
                      type esdma_types:esdma-rack-num-enum;
                    }

                    leaf card {
                      type esdma_types:esdma-cpu;
                      description
                        "Card to list the switch FDB information for";
                    }

                    leaf switch-id {
                      type esdma_types:esdma-switch-type-enum;
                      description
                        "Switch type";
                    }

                    leaf num-entries {
                      type uint32;
                      description
                        "Number of FDB entries in the table.";
                    }

                    leaf has-trunk-entry {
                      type uint8;
                      description
                        "FDB entries contain an entry from the trunk";
                    }

                    leaf trunk-entry-message {
                      type string;
                      description
                        "Message displayed when an FDB entry contains an entry for a trunk member port";
                    }

                    container fdb-block {
                      list fdb-entry {
                        key "fdb-index";
                        leaf fdb-index {
                          type uint32;
                        }

                        leaf fdb-mac-addr {
                          type ietf:mac-address;
                        }

                        leaf fdb-vlan {
                          type esdma_types:vlan-id-type;
                        }

                        leaf fdb-vlan-hex {
                          type leafref {
                            path "../fdb-vlan";
                          }
                        }

                        leaf fdb-port {
                          type esdma_types:esdma-switch-fdb-ports;
                          description
                            "Switch port MAC address learned on.";
                        }

                        leaf fdb-trap-entry {
                          type esdma_types:esdma-switch-yes-no-enum;
                        }

                        leaf fdb-static-entry {
                          type esdma_types:esdma-switch-yes-no-enum;
                        }

                        leaf-list fdb-synced-cores {
                          type uint8;
                        }
                      }  // list fdb-entry
                    }  // container fdb-block
                  }  // list location
                }  // container switch-fdb-common
              }  // list port-iter
            }  // container port

            container statistics {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                  description "Card";
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                  description "Switch type";
                }

                container counter-info {
                  leaf fdb-shadow-entries {
                    type uint32;
                  }

                  leaf fdb-max-shadow-entries {
                    type uint32;
                  }

                  leaf fdb-max-hash-chain {
                    type uint32;
                  }

                  leaf fdb-entries-added {
                    type uint32;
                  }

                  leaf fdb-entries-deleted {
                    type uint32;
                  }

                  leaf fdb-entries-updated {
                    type uint32;
                  }

                  leaf fdb-flushes {
                    type uint32;
                  }

                  leaf fdb-address-updates {
                    type uint32;
                  }

                  leaf fdb-new-addresses {
                    type uint32;
                  }

                  leaf fdb-aged-updates {
                    type uint32;
                  }

                  leaf fdb-transplant-updates {
                    type uint32;
                  }

                  leaf fdb-forwarding-updates {
                    type uint32;
                  }

                  leaf fdb-address-insert-errors {
                    type uint32;
                  }

                  leaf fdb-address-update-errors {
                    type uint32;
                  }

                  leaf fdb-memory-errors {
                    type uint32;
                  }

                  leaf fdb-allocation-errors {
                    type uint32;
                  }

                  leaf fdb-address-updates-queued {
                    type uint32;
                  }

                  leaf fdb-address-queue-full {
                    type esdma_types:esdma-switch-yes-no-enum;
                  }

                  leaf fdb-forwarding-updates-queued {
                    type uint32;
                  }

                  leaf fdb-forwarding-queue-full {
                    type esdma_types:esdma-switch-yes-no-enum;
                  }
                }  // container counter-info

                list core-id {
                  key "core";
                  leaf core {
                    type int32;
                  }

                  leaf core-entries {
                    type uint32;
                  }

                  leaf core-static-entries {
                    type uint32;
                  }
                }  // list core-id
              }  // list location
            }  // container statistics

            container switch-fdb-common {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                  description
                    "Card to list the switch FDB information for";
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                  description "Switch type";
                }

                leaf num-entries {
                  type uint32;
                  description
                    "Number of FDB entries in the table.";
                }

                leaf has-trunk-entry {
                  type uint8;
                  description
                    "FDB entries contain an entry from the trunk";
                }

                leaf trunk-entry-message {
                  type string;
                  description
                    "Message displayed when an FDB entry contains an entry for a trunk member port";
                }

                container fdb-block {
                  list fdb-entry {
                    key "fdb-index";
                    leaf fdb-index {
                      type uint32;
                    }

                    leaf fdb-mac-addr {
                      type ietf:mac-address;
                    }

                    leaf fdb-vlan {
                      type esdma_types:vlan-id-type;
                    }

                    leaf fdb-vlan-hex {
                      type leafref {
                        path "../fdb-vlan";
                      }
                    }

                    leaf fdb-port {
                      type esdma_types:esdma-switch-fdb-ports;
                      description
                        "Switch port MAC address learned on.";
                    }

                    leaf fdb-trap-entry {
                      type esdma_types:esdma-switch-yes-no-enum;
                    }

                    leaf fdb-static-entry {
                      type esdma_types:esdma-switch-yes-no-enum;
                    }

                    leaf-list fdb-synced-cores {
                      type uint8;
                    }
                  }  // list fdb-entry
                }  // container fdb-block
              }  // list location
            }  // container switch-fdb-common
          }  // container fdb

          container vlan {
            container vlan-detail {
              list vlan-id {
                key "vlan";
                leaf vlan {
                  type esdma_types:vlan-id-type;
                }

                container rules {
                  list location {
                    key "rack card switch-id";
                    leaf rack {
                      type esdma_types:esdma-rack-num-enum;
                    }

                    leaf card {
                      type esdma_types:esdma-cpu;
                      description
                        "Card that owns a switch of interest";
                    }

                    leaf switch-id {
                      type esdma_types:esdma-switch-type-enum;
                      description
                        "Switch type";
                    }

                    list port-iter {
                      key "port";
                      leaf port {
                        type esdma_types:esdma-switch-port-type;
                        description
                          "Switch port";
                      }

                      list rule-id {
                        leaf direction {
                          type esdma_types:switch-data-direction-enum;
                          description
                            "Packet direction this rule applies to";
                        }

                        leaf match-table {
                          type esdma_types:switch-table-type-enum;
                        }

                        leaf match-type {
                          type esdma_types:switch-match-type-enum;
                        }

                        leaf match-vlan-id {
                          type esdma_types:vlan-id-type;
                        }

                        leaf action {
                          type esdma_types:switch-action-type-enum;
                        }

                        leaf action-vlan-id {
                          type esdma_types:vlan-id-type;
                        }
                      }  // list rule-id
                    }  // list port-iter
                  }  // list location
                }  // container rules
              }  // list vlan-id
            }  // container vlan-detail

            container rules {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                  description
                    "Card that owns a switch of interest to display the VLAN configuration for";
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                  description "Switch type";
                }

                list port-iter {
                  key "port";
                  leaf port {
                    type esdma_types:esdma-switch-port-type;
                    description
                      "Switch port";
                  }

                  list vlan-id {
                    key "vlan";
                    leaf vlan {
                      type esdma_types:vlan-id-type;
                      description
                        "This VLAN represents a VLAN membership for this switch port. Multiple rules may exist to support this VLAN.";
                    }

                    list rule-id {
                      leaf direction {
                        type esdma_types:switch-data-direction-enum;
                        description
                          "Packet direction this rule applies to";
                      }

                      leaf match-table {
                        type esdma_types:switch-table-type-enum;
                      }

                      leaf match-type {
                        type esdma_types:switch-match-type-enum;
                      }

                      leaf match-vlan-id {
                        type esdma_types:vlan-id-type;
                      }

                      leaf action {
                        type esdma_types:switch-action-type-enum;
                      }

                      leaf action-vlan-id {
                        type esdma_types:vlan-id-type;
                      }
                    }  // list rule-id
                  }  // list vlan-id
                }  // list port-iter
              }  // list location
            }  // container rules

            container information {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                  description
                    "Card to list the switch VLAN information for";
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                  description "Switch type";
                }

                leaf serial-num {
                  type string;
                  description
                    "Rack serial number";
                }

                list sdr-id {
                  key "sdr";
                  leaf sdr {
                    type esdma_types:esdma-sdr-id;
                  }

                  leaf esd-sdr-name {
                    type string;
                  }

                  list vlan-id {
                    key "vlan";
                    leaf vlan {
                      type esdma_types:vlan-id-type;
                    }

                    leaf vlan-hex {
                      type leafref {
                        path "../vlan";
                      }
                    }

                    leaf vlan-use {
                      type string;
                    }
                  }  // list vlan-id
                }  // list sdr-id
              }  // list location

              container summary {
                list sdr-id {
                  key "sdr";
                  leaf sdr {
                    type esdma_types:esdma-sdr-id;
                  }

                  leaf esd-sdr-name {
                    type string;
                  }

                  list vlan-id {
                    key "vlan";
                    leaf vlan {
                      type esdma_types:vlan-id-type;
                    }

                    leaf vlan-hex {
                      type leafref {
                        path "../vlan";
                      }
                    }

                    leaf vlan-use {
                      type string;
                    }
                  }  // list vlan-id
                }  // list sdr-id
              }  // container summary
            }  // container information

            container membership {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                  description
                    "Card that owns a switch of interest to display the VLAN configuration for";
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                  description "Switch type";
                }

                list vlan-id {
                  key "vlan";
                  leaf vlan {
                    type esdma_types:vlan-id-type;
                  }

                  leaf vlan-hex {
                    type leafref {
                      path "../vlan";
                    }
                  }

                  leaf-list port {
                    type uint8;
                  }
                }  // list vlan-id
              }  // list location
            }  // container membership
          }  // container vlan

          container esd {
            list instance {
              key "process_name";
              config false;
              description
                "show traceable process instance names";
              leaf process_name {
                type string;
              }

              list trace {
                key "buffer";
                config false;
                description
                  "show traceable processes";
                leaf buffer {
                  type string;
                }

                list location {
                  key "location_name";
                  leaf location_name {
                    type string;
                  }

                  list all-options {
                    key "option";
                    leaf option {
                      type string;
                    }

                    list trace-blocks {
                      leaf data {
                        type string;
                        description
                          "Trace output block";
                      }
                    }  // list trace-blocks
                  }  // list all-options
                }  // list location
              }  // list trace
            }  // list instance
          }  // container esd

          container mgmt-agent {
            container esdma {
              list trace {
                key "buffer";
                config false;
                description
                  "show traceable processes";
                leaf buffer {
                  type string;
                }

                list location {
                  key "location_name";
                  leaf location_name {
                    type string;
                  }

                  list all-options {
                    key "option";
                    leaf option {
                      type string;
                    }

                    list trace-blocks {
                      leaf data {
                        type string;
                        description
                          "Trace output block";
                      }
                    }  // list trace-blocks
                  }  // list all-options
                }  // list location
              }  // list trace
            }  // container esdma

            container connections {
              container esdma-info {
                leaf active-esdma-address {
                  type inet:ip-address;
                }
              }  // container esdma-info

              list sdr-nm-client-id {
                leaf sdr-nm-ip-address {
                  type inet:ip-address;
                }

                leaf sdr-nm-port-num {
                  type inet:port-number;
                }
              }  // list sdr-nm-client-id

              leaf sdr-nm-num-clients {
                type uint32;
              }

              list esd-client-id {
                leaf esd-client-ip-address {
                  type inet:ip-address;
                }

                leaf esd-client-port-num {
                  type inet:port-number;
                }

                leaf esd-client-location {
                  type string;
                }

                leaf esd-client-switch-info-cached {
                  type esdma_types:esdma-switch-yes-no-enum;
                }

                leaf esd-client-sdr-info-cached {
                  type esdma_types:esdma-switch-yes-no-enum;
                }
              }  // list esd-client-id

              leaf esd-client-num-clients {
                type uint32;
              }

              list mlap-client-id {
                leaf mlap-client-ip-address {
                  type inet:ip-address;
                }

                leaf mlap-client-port-num {
                  type inet:port-number;
                }

                leaf mlap-client-location {
                  type string;
                }

                leaf mlap-client-switch-info-cached {
                  type esdma_types:esdma-switch-yes-no-enum;
                }
              }  // list mlap-client-id

              leaf mlap-client-num-clients {
                type uint32;
              }
            }  // container connections
          }  // container mgmt-agent

          container sdr {
            container sdr-detail {
              list sdr-id {
                key "sdr";
                leaf sdr {
                  type esdma_types:esdma-sdr-id;
                }

                container port-statistics {
                  list location {
                    key "rack card switch-id";
                    leaf rack {
                      type esdma_types:esdma-rack-num-enum;
                    }

                    leaf card {
                      type esdma_types:esdma-cpu;
                      description
                        "Card that owns a switch of interest";
                    }

                    leaf switch-id {
                      type esdma_types:esdma-switch-type-enum;
                      description
                        "Switch type";
                    }

                    list port-iter {
                      key "port";
                      leaf port {
                        type esdma_types:esdma-switch-port-type;
                        description
                          "Switch port";
                      }

                      list traffic-type-id {
                        key "traffic-type";
                        leaf traffic-type {
                          type esdma_types:esdma-sdr-traffic-type;
                        }

                        list direction-id {
                          key "direction";
                          leaf direction {
                            type esdma_types:switch-data-direction-enum;
                            description
                              "Packet direction this rule applies to";
                          }

                          list traffic-class-id {
                            key "tc";
                            leaf tc {
                              type esdma_types:switch-traffic-class-enum;
                              description
                                "Traffic class (0->7) for these statistics.";
                            }

                            leaf green-packets {
                              type uint64;
                              description
                                "Counts packets within the committed information rate for a traffic class on this VLAN.";
                            }

                            leaf yellow-packets {
                              type uint64;
                              description
                                "Counts packets above the committed information rate, but within the excess information rate for a traffic class on this VLAN.";
                            }

                            leaf red-packets {
                              type uint64;
                              description
                                "Counts packets above the excess information rate for a traffic class on this VLAN. Generally, these packets are dropped.";
                            }
                          }  // list traffic-class-id
                        }  // list direction-id
                      }  // list traffic-type-id
                    }  // list port-iter
                  }  // list location
                }  // container port-statistics
              }  // list sdr-id
            }  // container sdr-detail

            container port-statistics {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                  description
                    "Card that owns a switch of interest to display the SDR configuration for";
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                  description "Switch type";
                }

                list port-iter {
                  key "port";
                  leaf port {
                    type esdma_types:esdma-switch-port-type;
                    description
                      "Switch port";
                  }

                  list sdr-id {
                    key "sdr";
                    leaf sdr {
                      type esdma_types:esdma-sdr-id;
                    }

                    leaf esd-sdr-name {
                      type string;
                    }

                    list traffic-type-id {
                      key "traffic-type";
                      leaf traffic-type {
                        type esdma_types:esdma-sdr-traffic-type;
                      }

                      list direction-id {
                        key "direction";
                        leaf direction {
                          type esdma_types:switch-data-direction-enum;
                          description
                            "Packet direction this rule applies to";
                        }

                        leaf green-packets {
                          type uint64;
                          description
                            "Counts packets within the committed information rate for all traffic classes on this SDR.";
                        }

                        leaf yellow-packets {
                          type uint64;
                          description
                            "Counts packets above the committed information rate, but within the excess information rate for all traffic classes on this SDR.";
                        }

                        leaf red-packets {
                          type uint64;
                          description
                            "Counts packets above the excess information rate for all traffic classes on this SDR. Generally, these packets are dropped.";
                        }
                      }  // list direction-id
                    }  // list traffic-type-id
                  }  // list sdr-id
                }  // list port-iter
              }  // list location
            }  // container port-statistics

            container global-statistics {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                  description
                    "Card that owns a switch of interest to display the SDR configuration for";
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                  description "Switch type";
                }

                list sdr-id {
                  key "sdr";
                  leaf sdr {
                    type esdma_types:esdma-sdr-id;
                  }

                  leaf esd-sdr-name {
                    type string;
                  }

                  list traffic-type-id {
                    key "traffic-type";
                    leaf traffic-type {
                      type esdma_types:esdma-sdr-traffic-type;
                    }

                    list traffic-class-id {
                      key "tc";
                      leaf tc {
                        type esdma_types:switch-traffic-class-enum;
                        description
                          "Traffic class (0->7) for these statistics.";
                      }

                      leaf green-packets {
                        type uint64;
                        description
                          "Counts packets within the committed information rate for a traffic class on this VLAN.";
                      }

                      leaf yellow-packets {
                        type uint64;
                        description
                          "Counts packets above the committed information rate, but within the excess information rate for a traffic class on this VLAN.";
                      }

                      leaf red-packets {
                        type uint64;
                        description
                          "Counts packets above the excess information rate for a traffic class on this VLAN. Generally, these packets are dropped.";
                      }
                    }  // list traffic-class-id
                  }  // list traffic-type-id
                }  // list sdr-id
              }  // list location
            }  // container global-statistics

            container policers {
              list location {
                key "rack card switch-id";
                leaf rack {
                  type esdma_types:esdma-rack-num-enum;
                }

                leaf card {
                  type esdma_types:esdma-cpu;
                }

                leaf switch-id {
                  type esdma_types:esdma-switch-type-enum;
                }

                container esd-policer-status {
                  container indent-group {
                    leaf esd-port-policing-enabled {
                      type esdma_types:esdma-switch-yes-no-enum;
                    }

                    leaf esd-port-committed-burst-size {
                      type uint32;
                    }

                    leaf esd-port-peak-burst-size {
                      type uint32;
                    }

                    leaf esd-port-policer-mru {
                      type uint32;
                    }

                    leaf esd-global-policing-enabled {
                      type esdma_types:esdma-switch-yes-no-enum;
                    }

                    leaf esd-global-committed-burst-size {
                      type uint32;
                    }

                    leaf esd-global-peak-burst-size {
                      type uint32;
                    }

                    leaf esd-global-policer-mru {
                      type uint32;
                    }
                  }  // container indent-group
                }  // container esd-policer-status

                list sdr-id {
                  key "sdr";
                  leaf sdr {
                    type esdma_types:esdma-sdr-id;
                  }

                  leaf esd-sdr-name {
                    type string;
                  }

                  leaf esd-sdr-cir {
                    type esdma_types:esd-percentage;
                  }

                  leaf esd-sdr-pir {
                    type esdma_types:esd-percentage;
                  }

                  list esd-sdr-cos-type-iter {
                    key "esd-sdr-cos-type";
                    leaf esd-sdr-cos-type {
                      type esdma_types:esd-cir-eir-type;
                    }

                    leaf esd-sdr-cos-0 {
                      type esdma_types:esd-percentage;
                    }

                    leaf esd-sdr-cos-1 {
                      type esdma_types:esd-percentage;
                    }

                    leaf esd-sdr-cos-2 {
                      type esdma_types:esd-percentage;
                    }

                    leaf esd-sdr-cos-3 {
                      type esdma_types:esd-percentage;
                    }

                    leaf esd-sdr-cos-4 {
                      type esdma_types:esd-percentage;
                    }

                    leaf esd-sdr-cos-5 {
                      type esdma_types:esd-percentage;
                    }

                    leaf esd-sdr-cos-6 {
                      type esdma_types:esd-percentage;
                    }

                    leaf esd-sdr-cos-7 {
                      type esdma_types:esd-percentage;
                    }
                  }  // list esd-sdr-cos-type-iter
                }  // list sdr-id
              }  // list location
            }  // container policers
          }  // container sdr

          container port-state {
            list location {
              key "rack card switch-id";
              leaf rack {
                type esdma_types:esdma-rack-num-enum;
              }

              leaf card {
                type esdma_types:esdma-cpu;
                description
                  "Card that owns a switch of interest";
              }

              leaf switch-id {
                type esdma_types:esdma-switch-type-enum;
                description "Switch type";
              }

              list port-iter {
                tailf:action "down" {
                  output {
                    leaf "result" {
                      type "string";
                      mandatory "true";
                    }
                  }
                }
                tailf:action "up" {
                  output {
                    leaf "result" {
                      type "string";
                      mandatory "true";
                    }
                  }
                }
                tailf:action "test" {
                  output {
                    leaf "result" {
                      type "string";
                      mandatory "true";
                    }
                  }
                }
                key "port";
                leaf port {
                  type esdma_types:esdma-switch-port-type;
                  description "Switch port";
                }
              }  // list port-iter
            }  // list location
          }  // container port-state

          container trunk {
            list location {
              key "rack card switch-id";
              leaf rack {
                type esdma_types:esdma-rack-num-enum;
                description
                  "Rack to display the switch trunk group information for";
              }

              leaf card {
                type esdma_types:esdma-cpu;
                description
                  "Card to display the switch trunk group information for";
              }

              leaf switch-id {
                type esdma_types:esdma-switch-type-enum;
                description
                  "Switch type to display the switch trunk group information for";
              }

              leaf trunk-member-count {
                type uint32;
                description
                  "Number of member ports in the trunk group";
              }

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

              list trunk-member-port-iter {
                key "trunk-member-port";
                leaf trunk-member-port {
                  type uint32;
                  description
                    "Trunk Member Port";
                }

                leaf trunk-member-status {
                  type esdma_types:esdma-trunk-member-status;
                  description
                    "Trunk Member Status";
                }
              }  // list trunk-member-port-iter
            }  // list location
          }  // container trunk

          container switch-debug-cont {
            container debug {
              container counters {
                list location {
                  key "rack card switch-id";
                  leaf rack {
                    type esdma_types:esdma-rack-num-enum;
                  }

                  leaf card {
                    type esdma_types:esdma-cpu;
                  }

                  leaf switch-id {
                    type esdma_types:esdma-switch-type-enum;
                  }

                  container counters {
                    leaf phy-polling-enabled {
                      type boolean;
                    }

                    leaf tx-thread-wdog-cnt {
                      type uint64;
                    }

                    leaf rx-thread-wdog-cnt {
                      type uint64;
                    }

                    leaf task-lock-longest-wait-time {
                      type uint64;
                    }

                    leaf task-lock-longest-wait-event {
                      type uint32;
                    }

                    leaf task-lock-longest-held-time {
                      type uint64;
                    }

                    leaf task-lock-longest-held-event {
                      type uint32;
                    }

                    leaf task-unlock-longest-wait-time {
                      type uint64;
                    }

                    leaf task-unlock-longest-wait-event {
                      type uint32;
                    }

                    leaf dma-max-rx-dequeued-per-int {
                      type uint64;
                    }

                    leaf dma-rx-packets-dequeued {
                      type uint64;
                    }

                    leaf dma-rx-packet-dequeue-errors {
                      type uint64;
                    }

                    leaf dma-tx-packets-queued {
                      type uint64;
                    }

                    leaf dma-tx-packets-completed {
                      type uint64;
                    }

                    leaf dma-tx-packet-no-msg-errors {
                      type uint64;
                    }

                    leaf dma-tx-packet-msg-too-big-errors {
                      type uint64;
                    }

                    leaf dma-tx-packet-no-buffer-errors {
                      type uint64;
                    }

                    leaf dma-tx-packet-queue-errors {
                      type uint64;
                    }

                    leaf dma-tx-packet-completion-errors {
                      type uint64;
                    }

                    leaf dma-max-tx-freed-per-int {
                      type uint64;
                    }

                    leaf dma-tx-buf-alloc-count {
                      type uint64;
                    }

                    leaf dma-tx-buf-free-count {
                      type uint64;
                    }

                    list switch-core {
                      key "core";
                      leaf core {
                        type uint8;
                      }

                      leaf msi-count {
                        type uint64;
                      }

                      leaf aer-count {
                        type uint64;
                      }

                      leaf hp-count {
                        type uint64;
                      }

                      leaf wdog-count {
                        type uint64;
                      }

                      leaf core-task-lock-longest-wait-time {
                        type uint64;
                      }

                      leaf core-task-lock-longest-held-time {
                        type uint64;
                      }

                      leaf core-task-unlock-longest-wait-time {
                        type uint64;
                      }
                    }  // list switch-core
                  }  // container counters
                }  // list location
              }  // container counters
            }  // container debug
          }  // container switch-debug-cont
        }  // container oper
      }  // container switch
    }  // container controller
  }  // module Cisco-IOS-XR-sysadmin-controllers-asr9k