module Cisco-IOS-XR-sysadmin-controllers-ncs5500-eyrie {

    yang-version 1;

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

    prefix calvados_controllers;

    import Cisco-IOS-XR-sysadmin-fabric-ncs5501 {
      prefix fabric;
    }
    import Cisco-IOS-XR-sysadmin-ethsw-esdma-cli-ncs5500 {
      prefix esdma;
    }
    import Cisco-IOS-XR-sysadmin-card-mgr {
      prefix card_mgr;
    }
    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) 2021-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-01-29" {
      description
        "Changed the implementation to not to have SFE and to have Switch";
    }

    semver:module-version "1.0.0";

    container controller {
      container fabric {
        description
          "Fabric resource commands";
        container oper {
          config false;
          container fgid {
            description
              "FGID management information";
            container information {
              list id {
                key "fgid_id";
                leaf fgid_id {
                  type fabric-types:fabric_fgid_id_type_ncs5500;
                }

                list hex_bitmaps {
                  key "rack_number";
                  leaf rack_number {
                    type int32;
                  }

                  leaf bitmap {
                    type string;
                  }
                }  // list hex_bitmaps

                list binary_bitmaps {
                  key "rack_number";
                  leaf rack_number {
                    type int32;
                  }

                  leaf bitmap {
                    type string;
                  }
                }  // list binary_bitmaps

                leaf total_asso_fabricq_ids {
                  type int32;
                }

                list asso_fabricq_ids {
                  key "fabricq_id";
                  leaf fabricq_id {
                    type string;
                  }
                }  // list asso_fabricq_ids

                leaf asso_client_info {
                  type string;
                }

                list drivers {
                  key "rack_number";
                  leaf rack_number {
                    type int32;
                  }

                  list clients {
                    key "client_idx";
                    leaf client_idx {
                      type int32;
                    }

                    leaf show_asic_0 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_0_bitmap {
                      type string;
                    }

                    leaf show_asic_1 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_1_bitmap {
                      type string;
                    }

                    leaf show_asic_2 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_2_bitmap {
                      type string;
                    }

                    leaf show_asic_3 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_3_bitmap {
                      type string;
                    }

                    leaf show_asic_4 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_4_bitmap {
                      type string;
                    }

                    leaf show_asic_5 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_5_bitmap {
                      type string;
                    }

                    leaf show_asic_6 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_6_bitmap {
                      type string;
                    }

                    leaf show_asic_7 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_7_bitmap {
                      type string;
                    }

                    leaf show_asic_8 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_8_bitmap {
                      type string;
                    }

                    leaf show_asic_9 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_9_bitmap {
                      type string;
                    }

                    leaf show_asic_10 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_10_bitmap {
                      type string;
                    }

                    leaf show_asic_11 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_11_bitmap {
                      type string;
                    }

                    leaf show_asic_12 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_12_bitmap {
                      type string;
                    }

                    leaf show_asic_13 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_13_bitmap {
                      type string;
                    }

                    leaf show_asic_14 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_14_bitmap {
                      type string;
                    }

                    leaf show_asic_15 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_15_bitmap {
                      type string;
                    }

                    leaf show_asic_16 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_16_bitmap {
                      type string;
                    }

                    leaf show_asic_17 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_17_bitmap {
                      type string;
                    }

                    leaf show_asic_18 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_18_bitmap {
                      type string;
                    }

                    leaf show_asic_19 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_19_bitmap {
                      type string;
                    }

                    leaf show_asic_20 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_20_bitmap {
                      type string;
                    }

                    leaf show_asic_21 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_21_bitmap {
                      type string;
                    }

                    leaf show_asic_22 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_22_bitmap {
                      type string;
                    }

                    leaf show_asic_23 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_23_bitmap {
                      type string;
                    }

                    leaf show_asic_24 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_24_bitmap {
                      type string;
                    }

                    leaf show_asic_25 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_25_bitmap {
                      type string;
                    }

                    leaf show_asic_26 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_26_bitmap {
                      type string;
                    }

                    leaf show_asic_27 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_27_bitmap {
                      type string;
                    }

                    leaf show_asic_28 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_28_bitmap {
                      type string;
                    }

                    leaf show_asic_29 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_29_bitmap {
                      type string;
                    }

                    leaf show_asic_30 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_30_bitmap {
                      type string;
                    }

                    leaf show_asic_31 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_31_bitmap {
                      type string;
                    }

                    leaf show_asic_32 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_32_bitmap {
                      type string;
                    }

                    leaf show_asic_33 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_33_bitmap {
                      type string;
                    }

                    leaf show_asic_34 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_34_bitmap {
                      type string;
                    }

                    leaf show_asic_35 {
                      type boolean;
                      default "false";
                    }

                    leaf asic_35_bitmap {
                      type string;
                    }
                  }  // list clients
                }  // list drivers
              }  // list id
            }  // container information

            container resource {
              list sdr {
                key "sdr_name";
                leaf sdr_name {
                  type string;
                }

                leaf description {
                  type string;
                  default
                    "Secure Domain Router name.";
                }

                list application {
                  key "app_name";
                  leaf app_name {
                    type string;
                  }

                  leaf description {
                    type string;
                    default "application.";
                  }

                  list ids_range {
                    key "id elements";
                    leaf id {
                      type fabric-types:fabric_fgid_id_type_ncs5500;
                    }

                    leaf elements {
                      type fabric-types:fabric_fgid_elements_type_ncs5500;
                    }

                    list fgid_ids {
                      key "fgid_id line_idx";
                      leaf fgid_id {
                        type string;
                      }

                      leaf line_idx {
                        type int32;
                      }

                      leaf sdr_name_h {
                        type string;
                      }

                      leaf app_name_h {
                        type string;
                      }
                    }  // list fgid_ids
                  }  // list ids_range
                }  // list application
              }  // list sdr
            }  // container resource

            container statistics {
              container all {
                list stats_list {
                  key "system_stats";
                  leaf system_stats {
                    type int32;
                  }

                  leaf system_total_fgids {
                    type uint32;
                  }

                  leaf system_inuse_fgids {
                    type uint32;
                  }

                  leaf system_hwm_fgids {
                    type uint32;
                  }
                }  // list stats_list

                list sdr_list {
                  key "sdr_name";
                  leaf sdr_name {
                    type string;
                  }

                  leaf description {
                    type string;
                    default
                      "Secure Domain Router name.";
                  }

                  leaf sdr_total_fgids {
                    type uint32;
                  }

                  leaf sdr_inuse_fgids {
                    type uint32;
                  }

                  leaf sdr_hwm_fgids {
                    type uint32;
                  }

                  list application {
                    key "app_name";
                    leaf app_name {
                      type string;
                    }

                    leaf description {
                      type string;
                      default "application.";
                    }

                    leaf app_id {
                      type uint32;
                    }

                    leaf pool_id {
                      type uint32;
                    }

                    leaf inuse_fgids {
                      type uint32;
                    }

                    leaf hwm_fgids {
                      type uint32;
                    }
                  }  // list application
                }  // list sdr_list

                list pool_list {
                  key "pool_id";
                  leaf pool_id {
                    type uint32;
                  }

                  leaf pool_name {
                    type string;
                  }

                  leaf pool_type {
                    type string;
                  }

                  leaf start_fgid {
                    type string;
                  }

                  leaf total_fgids {
                    type uint32;
                  }

                  leaf current_fgids {
                    type uint32;
                  }

                  leaf hwm_fgids {
                    type uint32;
                  }
                }  // list pool_list
              }  // container all

              container sdr {
                list sdr_list {
                  key "sdr_name";
                  leaf sdr_name {
                    type string;
                  }

                  leaf description {
                    type string;
                    default
                      "Secure Domain Router name.";
                  }

                  leaf sdr_total_fgids {
                    type uint32;
                  }

                  leaf sdr_inuse_fgids {
                    type uint32;
                  }

                  leaf sdr_hwm_fgids {
                    type uint32;
                  }

                  list application {
                    key "app_name";
                    leaf app_name {
                      type string;
                    }

                    leaf description {
                      type string;
                      default "application.";
                    }

                    leaf app_id {
                      type uint32;
                    }

                    leaf pool_id {
                      type uint32;
                    }

                    leaf inuse_fgids {
                      type uint32;
                    }

                    leaf hwm_fgids {
                      type uint32;
                    }
                  }  // list application
                }  // list sdr_list
              }  // container sdr

              container pool {
                list pool_list {
                  key "pool_id";
                  leaf pool_id {
                    type uint32;
                  }

                  leaf pool_name {
                    type string;
                  }

                  leaf pool_type {
                    type string;
                  }

                  leaf start_fgid {
                    type string;
                  }

                  leaf total_fgids {
                    type uint32;
                  }

                  leaf current_fgids {
                    type uint32;
                  }

                  leaf hwm_fgids {
                    type uint32;
                  }
                }  // list pool_list
              }  // container pool

              container system {
                list stats_list {
                  key "system_stats";
                  leaf system_stats {
                    type int32;
                  }

                  leaf system_total_fgids {
                    type uint32;
                  }

                  leaf system_inuse_fgids {
                    type uint32;
                  }

                  leaf system_hwm_fgids {
                    type uint32;
                  }
                }  // list stats_list
              }  // container system
            }  // container statistics

            container fgid_mgr {
              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 fgid_mgr

            list program_error {
              key "start end";
              leaf start {
                type fabric-types:fabric_fgid_start_id_type_ncs5500;
              }

              leaf end {
                type fabric-types:fabric_fgid_end_id_type_ncs5500;
              }

              list rack {
                key "rack_id";
                leaf rack_id {
                  type int32;
                }

                leaf rack_id_str {
                  type string;
                }

                leaf fgids_in_error {
                  type string;
                }

                leaf found_fgids_in_error {
                  type boolean;
                }

                leaf total_error_fgids {
                  type int32;
                }

                leaf incorrect_fgids_range {
                  type boolean;
                }

                leaf cmd_not_supported {
                  type boolean;
                }
              }  // list rack
            }  // list program_error
          }  // container fgid
        }  // container oper
      }  // container fabric

      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 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 trace {
            list location {
              key "location_str";
              leaf location_str {
                type string;
              }

              container esd {
                list trace {
                  key "buffer";
                  config false;
                  leaf buffer {
                    type string;
                  }

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

                    list trace-blocks {
                      leaf data {
                        type string;
                      }
                    }  // list trace-blocks
                  }  // list all-options
                }  // list trace
              }  // container esd

              container esd-EPC-SW {
                list trace {
                  key "buffer";
                  config false;
                  leaf buffer {
                    type string;
                  }

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

                    list trace-blocks {
                      leaf data {
                        type string;
                      }
                    }  // list trace-blocks
                  }  // list all-options
                }  // list trace
              }  // container esd-EPC-SW

              container esd-EOBC-SW {
                list trace {
                  key "buffer";
                  config false;
                  leaf buffer {
                    type string;
                  }

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

                    list trace-blocks {
                      leaf data {
                        type string;
                      }
                    }  // list trace-blocks
                  }  // list all-options
                }  // list trace
              }  // container esd-EOBC-SW
            }  // list location
          }  // container trace

          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 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 oper
      }  // container switch

      container card_mgr {
        description
          "Card Manager module information";
        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 inventory {
          config false;
          description
            "Card inventory information";
          container summary {
            config false;
            description
              "Card inventory summary";
            list card_mgr_inv_summary {
              key "location";
              description
                "Card Manager Inventory Summary";
              leaf location {
                type string;
                mandatory true;
                description "Card location";
              }

              leaf card_mgr_inv_PID_string {
                type string;
                description
                  "Card inventory PID";
              }

              leaf card_mgr_inv_slot_number {
                type uint32;
                description
                  "Card inventory BP ID";
              }

              leaf card_mgr_inv_serial_number {
                type string;
                description
                  "Card inventory Serial Number";
              }

              leaf card_mgr_inv_hw_version {
                type string;
                description
                  "Card inventory HW Ver";
              }

              leaf card_mgr_inv_card_state {
                type string;
                description
                  "Card inventory Card State";
              }
            }  // list card_mgr_inv_summary
          }  // container summary

          container detail {
            config false;
            description
              "Card Manager inventory detail information";
            list card_mgr_inv_detail {
              key "location";
              description "Card location";
              leaf location {
                type string;
                description "Card location";
              }

              container card_mgr_inv_detail_list {
                description
                  "card_mgr inventory detail list";
                leaf-list card_mgr_inv_detail_values {
                  type string;
                  description
                    "card_mgr inventory detail value";
                }
              }  // container card_mgr_inv_detail_list
            }  // list card_mgr_inv_detail
          }  // container detail
        }  // container inventory

        container event-history {
          config false;
          description "Card Event History";
          container brief {
            config false;
            description
              "Show all events in brief format";
            list location {
              key "location";
              description "Select Location";
              leaf location {
                type string;
                description "Location";
              }

              container card_event_hist_brief {
                description
                  "Card Event History Brief";
                leaf-list card_event_hist_brief_values {
                  type string;
                  description
                    "Card Event History Brief Values";
                }
              }  // container card_event_hist_brief
            }  // list location
          }  // container brief

          container detail {
            config false;
            description
              "Show all events with additional detail information";
            list location {
              key "location";
              description "Select Location";
              leaf location {
                type string;
                description "Location";
              }

              container card_event_hist_detail {
                description
                  "Card Event History Detail";
                leaf-list card_event_hist_detail_values {
                  type string;
                  description
                    "Card Event History Detail Values";
                }
              }  // container card_event_hist_detail
            }  // list location
          }  // container detail
        }  // container event-history

        container notif-history {
          config false;
          description
            "Card State Notification History";
          container brief {
            config false;
            description
              "Show all state notifications in brief format";
            list location {
              key "location";
              description "Select Location";
              leaf location {
                type string;
                description "Location";
              }

              container card_notif_hist_brief {
                description
                  "Notify Histroy Brief";
                leaf-list card_notif_hist_brief_values {
                  type string;
                  description
                    "Notify Histroy Brief Values";
                }
              }  // container card_notif_hist_brief
            }  // list location
          }  // container brief

          container detail {
            config false;
            description
              "Show all state notifications with additional detail information";
            list location {
              key "location";
              description "Select Location";
              leaf location {
                type string;
                description "Location";
              }

              container card_notif_hist_detail {
                description
                  "Notify Histroy Detail";
                leaf-list card_notif_hist_detail_values {
                  type string;
                  description
                    "Notify Histroy Detail Values";
                }
              }  // container card_notif_hist_detail
            }  // list location
          }  // container detail
        }  // container notif-history

        container oir-history {
          config false;
          description "Cards OIR History";
          list rack {
            key "rack";
            description "Select Rack";
            leaf rack {
              type string;
              description "Rack";
            }

            container card_oir_hist {
              description
                "Cards OIR History";
              leaf-list card_oir_events {
                type string;
                description
                  "Cards OIR Events";
              }
            }  // container card_oir_hist
          }  // list rack
        }  // container oir-history

        container iofpga {
          config false;
          description "IOFPGA information";
          container register {
            config false;
            description
              "IOFPGA Register information";
            container cpu {
              config false;
              description
                "CPU-IOFPGA Register information";
              list register_location {
                key "register_location";
                config false;
                description "Card location";
                leaf register_location {
                  type string;
                  description "Location";
                }

                list iofpga_block_number {
                  key "iofpga_block_num";
                  config false;
                  description
                    "Register Group ID";
                  leaf iofpga_block_num {
                    type uint32;
                    description "GP";
                  }

                  leaf block_location {
                    type string;
                    description "Location";
                  }

                  leaf iofpga_block_nm {
                    type string;
                    description "Block NM";
                  }

                  list iofpga_register_number {
                    key "index";
                    description
                      "Register Number";
                    leaf index {
                      type uint32;
                      description
                        "Register IDX";
                    }

                    leaf iofpga_register_name {
                      type string;
                      description
                        "Register Name";
                    }

                    list iofpga_data {
                      description
                        "IOFPGA DATA";
                      leaf name {
                        type string;
                        description
                          "Register Name";
                      }

                      leaf offset {
                        type uint32;
                        description
                          "Register Offset";
                      }

                      leaf value {
                        type uint32;
                        description
                          "Register Value";
                      }
                    }  // list iofpga_data
                  }  // list iofpga_register_number
                }  // list iofpga_block_number

                list iofpga_offset {
                  key "hex_offset";
                  config false;
                  description
                    "Register Offset Address";
                  leaf hex_offset {
                    type HexOffset;
                    description
                      "Register Hex Offset";
                  }

                  list iofpga_reg_offset_data {
                    description
                      "Register Offset Data";
                    leaf iofpga_reg_off_addr {
                      type uint32;
                      description
                        "Register Offset Address";
                    }

                    leaf reg_off_value {
                      type string;
                      description
                        "Register Offset Value";
                    }
                  }  // list iofpga_reg_offset_data
                }  // list iofpga_offset

                list iofpga_address {
                  key "start_hex_addr end_hex_addr";
                  config false;
                  description
                    "Register Range to fetch data";
                  leaf start_hex_addr {
                    type startHexOffset;
                    description
                      "Register Start Hex Address";
                  }

                  leaf end_hex_addr {
                    type endHexOffset;
                    description
                      "Register End Hex Address";
                  }

                  list iofpga_reg_range_addr_list {
                    key "iofpga_reg_range_addr";
                    description
                      "Register Range Hex Address";
                    leaf iofpga_reg_range_addr {
                      type uint32;
                      description
                        "Register Offset";
                    }

                    list iofpga_reg_data {
                      description
                        "Register Data";
                      leaf iofpga_reg_addr {
                        type uint32;
                        description
                          "Register Address";
                      }

                      leaf reg_value {
                        type string;
                        description
                          "Register Value";
                      }
                    }  // list iofpga_reg_data
                  }  // list iofpga_reg_range_addr_list
                }  // list iofpga_address
              }  // list register_location
            }  // container cpu

            container mb {
              config false;
              description
                "Mother Board(MB)-IOFPGA Register information";
              list register_location {
                key "register_location";
                config false;
                description "Card location";
                leaf register_location {
                  type string;
                  description "Location";
                }

                list iofpga_block_number {
                  key "iofpga_block_num";
                  config false;
                  description
                    "Register Group ID";
                  leaf iofpga_block_num {
                    type uint32;
                    description "GP";
                  }

                  leaf block_location {
                    type string;
                    description "Location";
                  }

                  leaf iofpga_block_nm {
                    type string;
                    description "Block NM";
                  }

                  list iofpga_register_number {
                    key "index";
                    description
                      "Register Number";
                    leaf index {
                      type uint32;
                      description
                        "Register IDX";
                    }

                    leaf iofpga_register_name {
                      type string;
                      description
                        "Register Name";
                    }

                    list iofpga_data {
                      description
                        "IOFPGA DATA";
                      leaf name {
                        type string;
                        description
                          "Register Name";
                      }

                      leaf offset {
                        type uint32;
                        description
                          "Register Offset";
                      }

                      leaf value {
                        type uint32;
                        description
                          "Register Value";
                      }
                    }  // list iofpga_data
                  }  // list iofpga_register_number
                }  // list iofpga_block_number

                list iofpga_offset {
                  key "hex_offset";
                  config false;
                  description
                    "Register Offset Address";
                  leaf hex_offset {
                    type HexOffset;
                    description
                      "Register Hex Offset";
                  }

                  list iofpga_reg_offset_data {
                    description
                      "Register Offset Data";
                    leaf iofpga_reg_off_addr {
                      type uint32;
                      description
                        "Register Offset Address";
                    }

                    leaf reg_off_value {
                      type string;
                      description
                        "Register Offset Value";
                    }
                  }  // list iofpga_reg_offset_data
                }  // list iofpga_offset

                list iofpga_address {
                  key "start_hex_addr end_hex_addr";
                  config false;
                  description
                    "Register Range to fetch data";
                  leaf start_hex_addr {
                    type startHexOffset;
                    description
                      "Register Start Hex Address";
                  }

                  leaf end_hex_addr {
                    type endHexOffset;
                    description
                      "Register End Hex Address";
                  }

                  list iofpga_reg_range_addr_list {
                    key "iofpga_reg_range_addr";
                    description
                      "Register Range Hex Address";
                    leaf iofpga_reg_range_addr {
                      type uint32;
                      description
                        "Register Offset";
                    }

                    list iofpga_reg_data {
                      description
                        "Register Data";
                      leaf iofpga_reg_addr {
                        type uint32;
                        description
                          "Register Address";
                      }

                      leaf reg_value {
                        type string;
                        description
                          "Register Value";
                      }
                    }  // list iofpga_reg_data
                  }  // list iofpga_reg_range_addr_list
                }  // list iofpga_address
              }  // list register_location
            }  // container mb

            container dc {
              config false;
              description
                "Daughter Card(DC)-IOFPGA Register information";
              list register_location {
                key "register_location";
                config false;
                description "Card location";
                leaf register_location {
                  type string;
                  description "Location";
                }

                list iofpga_block_number {
                  key "iofpga_block_num";
                  config false;
                  description
                    "Register Group ID";
                  leaf iofpga_block_num {
                    type uint32;
                    description "GP";
                  }

                  leaf block_location {
                    type string;
                    description "Location";
                  }

                  leaf iofpga_block_nm {
                    type string;
                    description "Block NM";
                  }

                  list iofpga_register_number {
                    key "index";
                    description
                      "Register Number";
                    leaf index {
                      type uint32;
                      description
                        "Register IDX";
                    }

                    leaf iofpga_register_name {
                      type string;
                      description
                        "Register Name";
                    }

                    list iofpga_data {
                      description
                        "IOFPGA DATA";
                      leaf name {
                        type string;
                        description
                          "Register Name";
                      }

                      leaf offset {
                        type uint32;
                        description
                          "Register Offset";
                      }

                      leaf value {
                        type uint32;
                        description
                          "Register Value";
                      }
                    }  // list iofpga_data
                  }  // list iofpga_register_number
                }  // list iofpga_block_number

                list iofpga_offset {
                  key "hex_offset";
                  config false;
                  description
                    "Register Offset Address";
                  leaf hex_offset {
                    type HexOffset;
                    description
                      "Register Hex Offset";
                  }

                  list iofpga_reg_offset_data {
                    description
                      "Register Offset Data";
                    leaf iofpga_reg_off_addr {
                      type uint32;
                      description
                        "Register Offset Address";
                    }

                    leaf reg_off_value {
                      type string;
                      description
                        "Register Offset Value";
                    }
                  }  // list iofpga_reg_offset_data
                }  // list iofpga_offset

                list iofpga_address {
                  key "start_hex_addr end_hex_addr";
                  config false;
                  description
                    "Register Range to fetch data";
                  leaf start_hex_addr {
                    type startHexOffset;
                    description
                      "Register Start Hex Address";
                  }

                  leaf end_hex_addr {
                    type endHexOffset;
                    description
                      "Register End Hex Address";
                  }

                  list iofpga_reg_range_addr_list {
                    key "iofpga_reg_range_addr";
                    description
                      "Register Range Hex Address";
                    leaf iofpga_reg_range_addr {
                      type uint32;
                      description
                        "Register Offset";
                    }

                    list iofpga_reg_data {
                      description
                        "Register Data";
                      leaf iofpga_reg_addr {
                        type uint32;
                        description
                          "Register Address";
                      }

                      leaf reg_value {
                        type string;
                        description
                          "Register Value";
                      }
                    }  // list iofpga_reg_data
                  }  // list iofpga_reg_range_addr_list
                }  // list iofpga_address
              }  // list register_location
            }  // container dc
          }  // container register

          container flash {
            config false;
            description
              "IOFPGA SPI flash information";
            container info {
              config false;
              description
                "IOFPGA SPI flash content";
              list flash_location {
                key "flash_location";
                description
                  "Select Location";
                leaf flash_location {
                  type calvados:location-id;
                  description
                    "IOFPGA Flash Location";
                }

                container iofpga_flash_info {
                  description
                    "IOFPGA Flash Information";
                  leaf-list iofpga_flash_info_values {
                    type string;
                    description
                      "IOFPGA Flash Information Values";
                  }
                }  // container iofpga_flash_info
              }  // list flash_location
            }  // container info

            container status {
              config false;
              description
                "IOFPGA SPI flash status";
              list flash_location {
                key "flash_location";
                description
                  "IOFPGA Flash Location";
                leaf flash_location {
                  type calvados:location-id;
                  description
                    "IOFPGA Flash Location ID";
                }

                container iofpga_flash_status {
                  description
                    "IOFPGA Flash Status";
                  leaf-list iofpga_flash_status_values {
                    type string;
                    description
                      "IOFPGA Flash Status Values";
                  }
                }  // container iofpga_flash_status
              }  // list flash_location
            }  // container status
          }  // container flash
        }  // container iofpga

        container bootloader {
          config false;
          description
            "Bootloader information";
          container flash {
            config false;
            description
              "Bootloader SPI flash information";
            container info {
              config false;
              description
                "Bootloader SPI flash content";
              list flash_location {
                key "flash_location";
                description
                  "Select Location";
                leaf flash_location {
                  type calvados:location-id;
                  description "Location ID";
                }

                container bootldr_flash_info {
                  description
                    "Bootloader Flash Information";
                  leaf-list bootldr_flash_info_values {
                    type string;
                    description
                      "Bootloader Flash Information Values";
                  }
                }  // container bootldr_flash_info
              }  // list flash_location
            }  // container info

            container status {
              config false;
              description
                "Bootloader SPI flash status";
              list flash_location {
                key "flash_location";
                description
                  "Select Location";
                leaf flash_location {
                  type calvados:location-id;
                  description "Location ID";
                }

                container bootldr_flash_status {
                  description
                    "Bootloader flash status";
                  leaf-list bootldr_flash_status_values {
                    type string;
                    description
                      "Bootloader Flash Status Values";
                  }
                }  // container bootldr_flash_status
              }  // list flash_location
            }  // container status
          }  // container flash
        }  // container bootloader
      }  // container card_mgr
    }  // container controller
  }  // module Cisco-IOS-XR-sysadmin-controllers-ncs5500-eyrie