submodule Cisco-IOS-XR-ipv4-dhcpd-oper-sub1 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-ipv4-dhcpd-oper {
        prefix
          Cisco-IOS-XR-ipv4-dhcpd-oper;
    }

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

    organization "Cisco Systems, Inc.";

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

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR ipv4-dhcpd package operational data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-11-20" {
      description
        "Added Yang Support for ADT,to retrive statistcs with help of vrf/interface.
       2020-09-30
         Modified to accommodate cdm changes";
    }

    revision "2019-06-25" {
      description
        "Introduced an option to show dhcp rate limit hit counters.";
    }

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

    revision "2018-09-20" {
      description "Fixing yang gaps.";
    }

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

    semver:module-version "1.1.0";
    semver:module-version "1.0.1";

    typedef Vrf-string {
      type string {
        length "0..33";
      }
      description "Vrf string";
    }

    typedef Dhcp-issu-version {
      type enumeration {
        enum "version1" {
          value 0;
          description "Version 1";
        }
        enum "version2" {
          value 1;
          description "Version 2";
        }
      }
      description "Dhcp issu version";
    }

    typedef Dhcp-issu-phase {
      type enumeration {
        enum "phase-not-started" {
          value 0;
          description
            "An ISSU event has not started";
        }
        enum "phase-load" {
          value 1;
          description "ISSU Load Phase";
        }
        enum "phase-run" {
          value 2;
          description "ISSU Run Phase";
        }
        enum "phase-completed" {
          value 3;
          description
            "An ISSU event has completed successfully";
        }
        enum "phase-aborted" {
          value 4;
          description
            "An ISSU event has aborted";
        }
      }
      description "Dhcp issu phase";
    }

    typedef Dhcp-issu-role {
      type enumeration {
        enum "role-primary" {
          value 0;
          description "Primary role";
        }
        enum "role-secondary" {
          value 1;
          description "Secondary role";
        }
      }
      description "Dhcp issu role";
    }

    typedef Bag-dhcpd-intf-srg-role {
      type enumeration {
        enum "none" {
          value 0;
          description
            "DHCPv4 Interface SRG role NONE";
        }
        enum "master" {
          value 1;
          description
            "DHCPv4 Interface SRG role Master";
        }
        enum "slave" {
          value 2;
          description
            "DHCPv4 Interface SRG role Slave";
        }
      }
      description "Bag dhcpd intf srg role";
    }

    typedef Bag-dhcpd-proxy-state {
      type enumeration {
        enum "initializing" {
          value 0;
          description "Initializing";
        }
        enum "selecting" {
          value 1;
          description "Selecting";
        }
        enum "requesting" {
          value 2;
          description "Requesting";
        }
        enum "bound" {
          value 3;
          description "Bound";
        }
        enum "renewing" {
          value 4;
          description "Renewing";
        }
        enum "informing" {
          value 5;
          description "Informing";
        }
        enum "deleting" {
          value 6;
          description "Deleting";
        }
        enum "create-dpm" {
          value 7;
          description "Create dpm";
        }
        enum "offer-sent" {
          value 8;
          description "Offer sent";
        }
        enum "update-dpm" {
          value 9;
          description "Update dpm";
        }
        enum "route-install" {
          value 10;
          description "Route install";
        }
        enum "disc-dpm" {
          value 11;
          description "Disc dpm";
        }
        enum "renew-new-intf" {
          value 12;
          description "Renew new intf";
        }
        enum "other-intf-dpm" {
          value 13;
          description "Other intf dpm";
        }
        enum "request-dpm" {
          value 14;
          description "Request dpm";
        }
        enum "change-addr-dpm" {
          value 15;
          description "Change addr dpm";
        }
        enum "max" {
          value 16;
          description "Max";
        }
      }
      description "Bag dhcpd proxy state";
    }

    typedef Proxy-lease-limit {
      type enumeration {
        enum "none" {
          value 0;
          description
            "Proxy lease limit type none";
        }
        enum "interface" {
          value 1;
          description
            "Proxy lease limit type interface";
        }
        enum "circuit-id" {
          value 2;
          description
            "Proxy lease limit type circuit ID";
        }
        enum "remote-id" {
          value 3;
          description
            "Proxy lease limit type remote ID";
        }
        enum "remote-id-circuit-id" {
          value 4;
          description
            "Proxy lease limit type remote ID + circuit ID";
        }
      }
      description
        "Proxy profile lease limit type";
    }

    typedef Broadcast-flag {
      type enumeration {
        enum "ignore" {
          value 0;
          description
            "Broadcast policy ignore";
        }
        enum "check" {
          value 1;
          description
            "Broadcast policy check";
        }
        enum "unicast-always" {
          value 2;
          description
            "Broadcast policy unicast always";
        }
      }
      description
        "Proxy profile broadcast flag";
    }

    typedef Relay-info-vpn-mode {
      type enumeration {
        enum "rfc" {
          value 0;
          description "RFC Mode";
        }
        enum "cisco" {
          value 1;
          description "Cisco Mode";
        }
      }
      description "Relay Info Vpn Mode";
    }

    typedef Relay-info-authenticate {
      type enumeration {
        enum "received" {
          value 0;
          description
            "Relay authenticate received";
        }
        enum "inserted" {
          value 1;
          description
            "Relay authenticate inserted";
        }
      }
      description
        "Profile relay authenticate";
    }

    typedef Relay-info-policy {
      type enumeration {
        enum "replace" {
          value 0;
          description "Relay policy replace";
        }
        enum "keep" {
          value 1;
          description "Relay policy keep";
        }
        enum "drop" {
          value 2;
          description "Relay policy drop";
        }
        enum "encapsulate" {
          value 3;
          description
            "Relay policy encapsulate";
        }
      }
      description
        "Proxy profile relay policy";
    }

    typedef String1 {
      type string {
        length "0..33";
      }
      description "String1";
    }

    grouping IPV4-DHCPD-RELAY-FILTERED-STATS {
      description
        "DHCP IPv4 filtered statistics";
      leaf received-packets {
        type uint64;
        description "Received packets";
      }

      leaf transmitted-packets {
        type uint64;
        description "Transmitted packets";
      }

      leaf dropped-packets {
        type uint64;
        description "Dropped packets";
      }
    }  // grouping IPV4-DHCPD-RELAY-FILTERED-STATS

    grouping IPV4-DHCPD-RELAY-STATS {
      description
        "ipv4 dhcpd relay stats parameters";
      list ipv4-dhcpd-relay-stat {
        description "ipv4 dhcpd relay stat";
        container statistics {
          description
            "Public relay statistics";
          uses IPV4-DHCPD-RELAY-FILTERED-STATS;
        }  // container statistics

        leaf relay-statistics-vrf-name {
          type string {
            length "0..33";
          }
          description "DHCP L3 VRF Name";
        }
      }  // list ipv4-dhcpd-relay-stat
    }  // grouping IPV4-DHCPD-RELAY-STATS

    grouping IPV4-DHCPD-RELAY-STATS-INFO {
      description
        "ipv4 dhcpd relay stats info";
      leaf relay-stats-timestamp {
        type uint32;
        description "Relay Stats timestamp";
      }
    }  // grouping IPV4-DHCPD-RELAY-STATS-INFO

    grouping IPV4-DHCPD-RELAY-PROFILE {
      description
        "ipv4 dhcpd relay profile parameters";
      leaf relay-profile-name {
        type string {
          length "0..65";
        }
        description "Profile Name";
      }

      leaf relay-profile-uid {
        type uint32;
        description "Profile UID";
      }

      leaf relay-profile-helper-count {
        type uint8;
        description "Helper address count";
      }

      leaf relay-profile-relay-info-option {
        type uint8;
        description "Relay info option";
      }

      leaf relay-profile-relay-info-policy {
        type uint8;
        description "Relay info policy";
      }

      leaf relay-profile-relay-info-allow-untrusted {
        type uint8;
        description "Relay info untrusted";
      }

      leaf relay-profile-relay-info-optionvpn {
        type uint8;
        description "Relay info option vpn";
      }

      leaf relay-profile-relay-info-optionvpn-mode {
        type Relay-info-vpn-mode;
        description
          "Relay info option vpn-mode";
      }

      leaf relay-profile-relay-info-check {
        type uint8;
        description "Relay info check";
      }

      leaf relay-profile-gi-addr-policy {
        type uint8;
        description "GIADDR policy";
      }

      leaf relay-profile-broadcast-flag-policy {
        type uint8;
        description "Broadcast policy";
      }

      leaf relay-profile-mac-mismatch-action {
        type uint8;
        description "Mac Mismatch Action";
      }

      leaf-list relay-profile-helper-address {
        type inet:ipv4-address;
        max-elements 32;
        description "Helper addresses";
      }

      leaf-list relay-profile-helper-vrf {
        type Vrf-string;
        max-elements 32;
        description "Helper address vrfs";
      }

      leaf-list relay-profile-gi-addr {
        type inet:ipv4-address;
        max-elements 32;
        description "Gateway addresses";
      }
    }  // grouping IPV4-DHCPD-RELAY-PROFILE

    grouping IPV4-DHCPD-SERVER-PROFILE {
      description
        "ipv4 dhcpd server profile parameters";
      leaf server-profile-name-xr {
        type string {
          length "0..65";
        }
        description "Profile Name";
      }

      leaf secure-arp {
        type boolean;
        description "Secure ARP";
      }

      leaf requested-address-check {
        type boolean;
        description
          "Requested Address Check";
      }

      leaf server-id-check {
        type boolean;
        description "Server ID Check";
      }

      leaf duplicate-mac-address-check {
        type boolean;
        description
          "Duplicate MAC Address Check";
      }

      leaf duplicate-ip-address-check {
        type boolean;
        description
          "Duplicate IP Address Check";
      }

      leaf is-move-allowed {
        type boolean;
        description
          "Is true if dhcp subscriber is allowed to move";
      }

      leaf bcast-policy {
        type uint8;
        description "Bcast Policy";
      }

      leaf giaddr-policy {
        type uint8;
        description "Giaddr Policy";
      }

      leaf subnet-mask {
        type inet:ipv4-address;
        description "Subnet Mask";
      }

      leaf server-pool-name {
        type string {
          length "0..65";
        }
        description "Pool Name";
      }

      leaf server-profile-lease {
        type uint32;
        description "Lease";
      }

      leaf server-profile-netbios-node-type {
        type uint8;
        description
          "Server netbios node type";
      }

      leaf server-bootfile-name {
        type string {
          length "0..256";
        }
        description "Server Bootfile name";
      }

      leaf server-domain-name {
        type string {
          length "0..256";
        }
        description "Server Domain name";
      }

      leaf server-profileiedge-check {
        type uint8;
        description "Server iEdge Check";
      }

      leaf server-profile-server-dns-count {
        type uint8;
        description "Server DNS Count";
      }

      leaf server-profiledefault-router-count {
        type uint8;
        description "Server default count ";
      }

      leaf server-profile-netbios-name-svr-count {
        type uint8;
        description
          "Server netbios svr count ";
      }

      leaf server-profile-time-svr-count {
        type uint8;
        description "Server time svr count ";
      }

      leaf lease-limit-type {
        type uint8;
        description "Lease Limit Type";
      }

      leaf lease-limit-count {
        type uint32;
        description "Lease Limit Count";
      }

      leaf-list server-profile-dns {
        type inet:ipv4-address;
        max-elements 9;
        description "Server DNS addresses";
      }

      leaf-list server-profile-default-router {
        type inet:ipv4-address;
        max-elements 9;
        description
          "Server default addresses";
      }

      leaf-list server-profile-netbious-name-server {
        type inet:ipv4-address;
        max-elements 9;
        description
          "Server netbios addresses";
      }

      leaf-list server-profile-time-server {
        type inet:ipv4-address;
        max-elements 9;
        description "Server Time addresses";
      }
    }  // grouping IPV4-DHCPD-SERVER-PROFILE

    grouping IPV4-DHCPD-DATABASE {
      description "IPv4 DHCP database";
      leaf configured {
        type boolean;
        description
          "Database feature configured";
      }

      leaf version {
        type uint32;
        description "Current file version";
      }

      leaf full-file-write-interval {
        type uint32;
        units "minute";
        description
          "Full file write interval in minutes";
      }

      leaf last-full-write-file-name {
        type string {
          length "0..64";
        }
        description
          "Last full write file name";
      }

      leaf last-full-write-time {
        type uint32;
        description
          "Last full write time since epoch";
      }

      leaf full-file-write-count {
        type uint32;
        description "Full file write count";
      }

      leaf failed-full-file-write-count {
        type uint32;
        description
          "Failed full file write count";
      }

      leaf full-file-record-count {
        type uint32;
        description "Full file record count";
      }

      leaf last-full-file-write-error-timestamp {
        type uint32;
        description
          "Last full file write error timestamp since epoch";
      }

      leaf incremental-file-write-interval {
        type uint32;
        units "minute";
        description
          "Incremental file write interval in minutes";
      }

      leaf last-incremental-write-file-name {
        type string {
          length "0..64";
        }
        description
          "Last incremental write file name";
      }

      leaf last-incremental-write-time {
        type uint32;
        description
          "Last incremental write time since epoch";
      }

      leaf incremental-file-write-count {
        type uint32;
        description
          "Incremental file write count";
      }

      leaf failed-incremental-file-write-count {
        type uint32;
        description
          "Failed incremental file write count";
      }

      leaf incremental-file-record-count {
        type uint32;
        description
          "Incremental file record count";
      }

      leaf last-incremental-file-write-error-timestamp {
        type uint32;
        description
          "Last incremental file write error timestamp
         since epoch";
      }
    }  // grouping IPV4-DHCPD-DATABASE

    grouping IPV4-DHCPD-BASE-CHILD-PROFILE-INFO {
      description
        "ipv4 dhcpd base child profile information";
      list ipv4-dhcpd-base-child-profile-info {
        description
          "ipv4 dhcpd base child profile info";
        leaf base-child-profile-name {
          type string {
            length "0..65";
          }
          description
            "Base Child Profile name";
        }

        leaf mode {
          type uint8;
          description "Profile mode";
        }

        leaf matched-option-code {
          type uint8;
          description "Matched option code";
        }

        leaf matched-option-len {
          type uint8;
          description "Matched option len";
        }

        leaf option-data {
          type yang:hex-string;
          description "Matched option data";
        }
      }  // list ipv4-dhcpd-base-child-profile-info
    }  // grouping IPV4-DHCPD-BASE-CHILD-PROFILE-INFO

    grouping IPV4-DHCPD-BASE-INTERFACE-REFERENCE {
      description
        "ipv4 dhcpd base profile reference";
      list ipv4-dhcpd-base-interface-reference {
        description
          "ipv4 dhcpd base interface reference";
        leaf base-reference-interface-name {
          type string {
            length "0..65";
          }
          description "Interface name";
        }
      }  // list ipv4-dhcpd-base-interface-reference
    }  // grouping IPV4-DHCPD-BASE-INTERFACE-REFERENCE

    grouping IPV4-DHCPD-BASE-PROFILE {
      description
        "IPv4 dhcpd base profile parameters";
      container interface-references {
        description "Interface references";
        uses IPV4-DHCPD-BASE-INTERFACE-REFERENCE;
      }  // container interface-references

      container child-profile-info {
        description "child profile info";
        uses IPV4-DHCPD-BASE-CHILD-PROFILE-INFO;
      }  // container child-profile-info

      leaf base-default-profile-name {
        type string {
          length "0..65";
        }
        description
          "Base Default Profile name";
      }

      leaf default-profile-mode {
        type uint8;
        description "Default Profile mode";
      }

      leaf relay-authenticate {
        type Relay-info-authenticate;
        description "Relay authenticate";
      }

      leaf remote-id {
        type string {
          length "0..768";
        }
        description
          "DHCP configured Remote ID";
      }

      leaf child-profile-count {
        type uint8;
        description "Child profile count";
      }

      leaf intf-ref-count {
        type uint8;
        description
          "Interface reference count";
      }
    }  // grouping IPV4-DHCPD-BASE-PROFILE

    grouping DHCPD-ISSU-STATUS-INFO {
      description "DHCP ISSU Status";
      leaf issu-sync-complete-time {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for the ISSU sync complete in
         nanoseconds since Epoch, i.e. since 00:00:00 UTC
         , January 1, 1970";
      }

      leaf issu-sync-start-time {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for the ISSU sync start in nanoseconds
         since Epoch, i.e. since 00:00:00 UTC, January 1,
         1970";
      }

      leaf issu-ready-time {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for the ISSU ready declaration in
         nanoseconds since Epoch, i.e. since 00:00:00 UTC
         , January 1, 1970";
      }

      leaf big-bang-time {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for the Big Bang notification time in
         nanoseconds since Epoch, i.e. since 00:00:00 UTC
         , January 1, 1970";
      }

      leaf primary-role-time {
        type uint64;
        units "nanosecond";
        description
          "Timestamp for the change to Primary role
         notification time in nanoseconds since Epoch, i
         .e. since 00:00:00 UTC, January 1, 1970";
      }

      leaf role {
        type Dhcp-issu-role;
        description
          "The current role of the DHCP process";
      }

      leaf phase {
        type Dhcp-issu-phase;
        description
          "The current ISSU phase of the DHCP process";
      }

      leaf version {
        type Dhcp-issu-version;
        description
          "The current version of the DHCP process in the
         context of an ISSU";
      }

      leaf issu-ready-issu-mgr-connection {
        type boolean;
        description
          "Whether or not DHCP is currently connected to
         ISSU Manager during the ISSU Load Phase";
      }

      leaf issu-ready-entries-replicate {
        type boolean;
        description
          "Whether or not DHCP has received all replicated
         entries during the ISSU Load Phase";
      }
    }  // grouping DHCPD-ISSU-STATUS-INFO

    grouping IPV4-DHCPD-BASE-DROP-STATS {
      description
        "DHCP IPv4 base drop statistics";
      leaf rate-limit-hit {
        type uint64;
        description "base Drop statistics";
      }
    }  // grouping IPV4-DHCPD-BASE-DROP-STATS

    grouping IPV4-DHCPD-PROXY-INTERFACE {
      description
        "ipv4 dhcpd proxy interface";
      leaf intf-ifhandle {
        type uint32;
        description
          "Ifhandle of the interface";
      }

      leaf vrf-name {
        type string {
          length "0..33";
        }
        description "VRF name";
      }

      leaf intf-mode {
        type uint32;
        description "Mode of interface";
      }

      leaf intf-is-ambiguous {
        type uint32;
        description "Is interface ambiguous";
      }

      leaf intf-profile-name {
        type string {
          length "0..65";
        }
        description
          "Name of profile attached to the interface";
      }

      leaf intf-lease-limit-type {
        type uint32;
        description
          "Lease limit type on interface";
      }

      leaf intf-lease-limit-count {
        type uint32;
        description
          "Lease limit count on interface";
      }

      leaf srg-role {
        type Bag-dhcpd-intf-srg-role;
        description
          "DHCPv6 Interface SRG role";
      }

      leaf mac-throttle {
        type boolean;
        description "Mac Throttle Status";
      }
    }  // grouping IPV4-DHCPD-PROXY-INTERFACE

    grouping IPV4-DHCPD-PROXY-BINDINGS-SUMMARY {
      description
        "DHCP IPv4 proxy bindings summary";
      leaf clients {
        type uint32;
        description
          "Total number of clients";
      }

      leaf initializing-clients {
        type uint32;
        description
          "Number of clients in init state";
      }

      leaf waiting-for-dpm-init {
        type uint32;
        description
          "Number of clients in Init DPM wait state";
      }

      leaf waiting-for-dpm-request {
        type uint32;
        description
          "Number of clients in Request DPM wait state";
      }

      leaf waiting-for-daps-init {
        type uint32;
        description
          "Number of clients in Init DAPS wait state";
      }

      leaf selecting-clients {
        type uint32;
        description
          "Number of clients in selecting state";
      }

      leaf offer-sent-for-client {
        type uint32;
        description
          "Number of clients in Offer sent state";
      }

      leaf requesting-clients {
        type uint32;
        description
          "Number of clients in requesting state";
      }

      leaf request-waiting-for-dpm {
        type uint32;
        description
          "Number of clients in Waiting for DPM with
         Request";
      }

      leaf ack-waiting-for-dpm {
        type uint32;
        description
          "Number of clients in Waiting for DPM with ACK";
      }

      leaf bound-clients {
        type uint32;
        description
          "Number of clients in bound state";
      }

      leaf renewing-clients {
        type uint32;
        description
          "Number of clients in renewing state";
      }

      leaf informing-clients {
        type uint32;
        description
          "Number of clients in informing state";
      }

      leaf reauthorizing-clients {
        type uint32;
        description
          "Number of clients in reauth state";
      }

      leaf waiting-for-dpm-disconnect {
        type uint32;
        description
          "Number of clients in waiting for DPM disconnect
         state";
      }

      leaf waiting-for-dpm-addr-change {
        type uint32;
        description
          "Number of clients in Waiting for DPM after addr
         change";
      }

      leaf deleting-clients-d {
        type uint32;
        description
          "Number of clients in deleting state";
      }

      leaf disconnected-clients {
        type uint32;
        description
          "Number of clients in disconnected state";
      }

      leaf restarting-clients {
        type uint32;
        description
          "Number of clients in restarting state";
      }
    }  // grouping IPV4-DHCPD-PROXY-BINDINGS-SUMMARY

    grouping IPV4-DHCPD-PROXY-BINDING {
      description
        "DHCP IPv4 proxy binding entry";
      leaf client-id-xr {
        type string {
          length "0..1275";
        }
        description "DHCP client identifier";
      }

      leaf mac-address {
        type string;
        description
          "DHCP client MAC address";
      }

      leaf vrf-name {
        type string {
          length "0..33";
        }
        description
          "DHCP client/subscriber VRF name";
      }

      leaf server-vrf-name {
        type string {
          length "0..33";
        }
        description "DHCP server VRF name";
      }

      leaf ip-address {
        type inet:ipv4-address;
        description "DHCP IP address";
      }

      leaf client-gi-addr {
        type inet:ipv4-address;
        description "DHCP client GIADDR";
      }

      leaf to-server-gi-addr {
        type inet:ipv4-address;
        description "DHCP to server GIADDR";
      }

      leaf server-ip-address {
        type inet:ipv4-address;
        description "DHCP server IP address";
      }

      leaf reply-server-ip-address {
        type inet:ipv4-address;
        description
          "DHCP reply server IP address";
      }

      leaf lease-time {
        type uint32;
        units "second";
        description "Lease time in seconds";
      }

      leaf remaining-lease-time {
        type uint32;
        units "second";
        description
          "Remaining lease time in seconds";
      }

      leaf state {
        type Bag-dhcpd-proxy-state;
        description "DHCP client state";
      }

      leaf interface-name {
        type xr:Interface-name;
        description
          "DHCP access interface to client";
      }

      leaf access-vrf-name {
        type string {
          length "0..33";
        }
        description
          "DHCP access interface VRF name";
      }

      leaf proxy-binding-outer-tag {
        type uint32;
        description "DHCP VLAN outer VLAN";
      }

      leaf proxy-binding-inner-tag {
        type uint32;
        description "DHCP VLAN inner VLAN";
      }

      leaf profile-name {
        type string {
          length "0..65";
        }
        description "DHCP profile name";
      }

      leaf selected-profile-name {
        type string {
          length "0..65";
        }
        description
          "DHCP Selected profile name";
      }

      leaf is-nak-next-renew {
        type boolean;
        description
          "Is true if DHCP next renew from client will be
         NAK'd";
      }

      leaf subscriber-label {
        type uint32;
        description "DHCP subscriber label";
      }

      leaf old-subscriber-label {
        type uint32;
        description
          "DHCP old subscriber label";
      }

      leaf subscriber-interface-name {
        type xr:Interface-name;
        description
          "DHCP subscriber interface";
      }

      leaf rx-circuit-id {
        type string {
          length "0..768";
        }
        description
          "DHCP received circuit ID";
      }

      leaf tx-circuit-id {
        type string {
          length "0..768";
        }
        description
          "DHCP transmitted circuit ID";
      }

      leaf rx-remote-id {
        type string {
          length "0..768";
        }
        description
          "DHCP received Remote ID";
      }

      leaf tx-remote-id {
        type string {
          length "0..768";
        }
        description
          "DHCP transmitted Remote ID";
      }

      leaf rx-vsiso {
        type string {
          length "0..768";
        }
        description "DHCP received VSISO";
      }

      leaf tx-vsiso {
        type string {
          length "0..768";
        }
        description "DHCP transmitted VSISO";
      }

      leaf is-auth-received {
        type boolean;
        description
          "Is true if authentication is on received
         option82";
      }

      leaf is-mbl-subscriber {
        type boolean;
        description
          "Is true if DHCP subscriber is Mobile";
      }

      leaf param-request {
        type string {
          length "0..513";
        }
        description
          "DHCP parameter request option";
      }

      leaf param-response {
        type string {
          length "0..2051";
        }
        description "DHCP saved options";
      }

      leaf session-start-time-epoch {
        type uint64;
        description
          "session start time epoch";
      }

      leaf srg-state {
        type uint32;
        description "DHCPV4 SRG state";
      }

      leaf srg-group-id {
        type uint16;
        description "srg group id";
      }

      leaf-list event-history {
        type uint32;
        max-elements 20;
        description "event history";
      }
    }  // grouping IPV4-DHCPD-PROXY-BINDING

    grouping IPV4-DHCPD-DISC-HISTORY {
      description
        "DHCP IPv4 disconnect history entry";
      leaf session-start-time-epoch {
        type uint64;
        description
          "session start time epoch";
      }

      leaf session-end-time-epoch {
        type uint64;
        description "session end time epoch";
      }

      leaf disc-reason {
        type string {
          length "0..256";
        }
        description "DiscReason";
      }

      leaf sub-label {
        type uint32;
        description "sub label";
      }

      leaf mac-address {
        type string {
          length "0..17";
        }
        description "MACAddress";
      }
    }  // grouping IPV4-DHCPD-DISC-HISTORY

    grouping IPV4-DHCPD-VRF-INTF-STATS {
      description
        "DHCP IPv4 proxy/server/base statistics for vrf
       and interface";
      container packet-info {
        description "Packet information";
        uses IPV4-DHCPD-PROXY-TYPE;
      }  // container packet-info

      leaf vrf-name-xr {
        type string {
          length "0..33";
        }
        description "DHCP L3 VRF name";
      }

      leaf interface-name-xr {
        type string {
          length "0..65";
        }
        description "DHCP L3 Interface name";
      }
    }  // grouping IPV4-DHCPD-VRF-INTF-STATS

    grouping IPV4-DHCPD-PROXY-STATS {
      description
        "DHCP IPv4 proxy statistics";
      list ipv4-dhcpd-proxy-stat {
        description "ipv4 dhcpd proxy stat";
        container statistics {
          description "Proxy statistics";
          uses IPV4-DHCPD-PROXY-FILTERED-STATS;
        }  // container statistics

        leaf vrf-name {
          type string {
            length "0..33";
          }
          description "DHCP L3 VRF name";
        }
      }  // list ipv4-dhcpd-proxy-stat
    }  // grouping IPV4-DHCPD-PROXY-STATS

    grouping IPV4-DHCPD-PROXY-INTERFACE-REFERENCE {
      description
        "ipv4 dhcpd proxy profile reference";
      list ipv4-dhcpd-proxy-interface-reference {
        description
          "ipv4 dhcpd proxy interface reference";
        leaf proxy-reference-interface-name {
          type string {
            length "0..65";
          }
          description "Interface name";
        }
      }  // list ipv4-dhcpd-proxy-interface-reference
    }  // grouping IPV4-DHCPD-PROXY-INTERFACE-REFERENCE

    grouping IPV4-DHCPD-PROXY-VRF-REFERENCE {
      description
        "ipv4 dhcpd proxy profile reference";
      list ipv4-dhcpd-proxy-vrf-reference {
        description
          "ipv4 dhcpd proxy vrf reference";
        leaf proxy-reference-vrf-name {
          type string {
            length "0..33";
          }
          description "VRF name";
        }
      }  // list ipv4-dhcpd-proxy-vrf-reference
    }  // grouping IPV4-DHCPD-PROXY-VRF-REFERENCE

    grouping IPV4-DHCPD-PROXY-PROFILE {
      description
        "IPv4 dhcpd proxy profile parameters";
      container vrf-references {
        description "VRF references";
        uses IPV4-DHCPD-PROXY-VRF-REFERENCE;
      }  // container vrf-references

      container interface-references {
        description "Interface references";
        uses IPV4-DHCPD-PROXY-INTERFACE-REFERENCE;
      }  // container interface-references

      leaf is-relay-option-enabled {
        type boolean;
        description
          "Is true if relay option is enabled";
      }

      leaf relay-policy {
        type Relay-info-policy;
        description "Relay policy";
      }

      leaf relay-authenticate {
        type Relay-info-authenticate;
        description "Relay authenticate";
      }

      leaf is-relay-allow-untrusted-enabled {
        type boolean;
        description
          "Is true if relay untrusted is enabled";
      }

      leaf is-relay-optionvpn-enabled {
        type boolean;
        description
          "Is true if relay VPN enabled";
      }

      leaf relay-optionvpn-enabled-mode {
        type Relay-info-vpn-mode;
        description
          "Relay VPN RFC/Cisco mode";
      }

      leaf is-relay-check {
        type boolean;
        description
          "Is true if relay check enabled";
      }

      leaf is-move-allowed {
        type boolean;
        description
          "Is true if dhcp subscriber is allowed to move";
      }

      leaf proxy-broadcast-flag-policy {
        type Broadcast-flag;
        description "Broadcast policy";
      }

      leaf proxy-profile-client-lease-time {
        type uint32;
        units "second";
        description
          "Client lease time in seconds";
      }

      leaf proxy-lease-limit-type {
        type Proxy-lease-limit;
        description "Lease limit type";
      }

      leaf proxy-lease-limit-count {
        type uint32;
        description "Lease limit count";
      }

      leaf-list profile-helper-address {
        type inet:ipv4-address;
        max-elements 8;
        description "Helper addresses";
      }

      leaf-list vrf-name {
        type String1;
        max-elements 8;
        description "VRF names";
      }

      leaf-list gi-addr {
        type inet:ipv4-address;
        max-elements 8;
        description "Gateway addresses";
      }
    }  // grouping IPV4-DHCPD-PROXY-PROFILE

    grouping IPV4-DHCPD-PROXY-FILTERED-STATS {
      description
        "DHCP IPv4 filtered statistics";
      leaf received-packets {
        type uint64;
        description "Received packets";
      }

      leaf transmitted-packets {
        type uint64;
        description "Transmitted packets";
      }

      leaf dropped-packets {
        type uint64;
        description "Dropped packets";
      }
    }  // grouping IPV4-DHCPD-PROXY-FILTERED-STATS

    grouping IPV4-DHCPD-PROXY-TYPE {
      description "Proxy packets";
      container discover {
        description "DHCP discover packets";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container discover

      container offer {
        description "DHCP offer packets";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container offer

      container request {
        description "DHCP request packets";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container request

      container decline {
        description "DHCP decline packets";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container decline

      container ack {
        description "DHCP ack packets";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container ack

      container nak {
        description "DHCP nak packets";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container nak

      container release {
        description "DHCP release packets";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container release

      container inform {
        description "DHCP inform packets";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container inform

      container lease-query {
        description
          "DHCP lease query packets";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container lease-query

      container lease-not-assigned {
        description
          "DHCP lease not assigned";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container lease-not-assigned

      container lease-unknown {
        description "DHCP lease unknown";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container lease-unknown

      container lease-active {
        description "DHCP lease active";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container lease-active

      container bootp-request {
        description "DHCP BOOTP request";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container bootp-request

      container bootp-reply {
        description "DHCP BOOTP reply";
        uses IPV4-DHCPD-PROXY-FILTERED-STATS;
      }  // container bootp-reply
    }  // grouping IPV4-DHCPD-PROXY-TYPE

    grouping IPV4-DHCPD-PROXY-STATS-INFO {
      description
        "ipv4 dhcpd proxy stats info";
      leaf proxy-stats-timestamp {
        type uint32;
        description "Proxy Stats timestamp";
      }
    }  // grouping IPV4-DHCPD-PROXY-STATS-INFO

    grouping IPV4-DHCPD-SNOOP-STATS {
      description
        "ipv4 dhcpd snoop stats parameters";
      leaf snoop-statistics-bridge-name {
        type string {
          length "0..74";
        }
        description "DHCP L2 bridge name";
      }

      leaf-list snoop-statistic {
        type uint64;
        max-elements 45;
        description
          "Public snoop statistics";
      }
    }  // grouping IPV4-DHCPD-SNOOP-STATS

    grouping IPV4-DHCPD-SNOOP-PROFILE {
      description
        "ipv4 dhcpd snoop profile parameters";
      leaf snoop-profile-name {
        type string {
          length "0..65";
        }
        description "Profile Name";
      }

      leaf snoop-profile-uid {
        type uint32;
        description "Profile unique ID";
      }

      leaf snoop-profile-relay-info-option {
        type uint8;
        description "Relay info option";
      }

      leaf snoop-profile-relay-info-allow-untrusted {
        type uint8;
        description
          "Allow untrusted relay info";
      }

      leaf snoop-profile-relay-info-policy {
        type uint8;
        description "Relay info policy";
      }

      leaf snoop-profile-trusted {
        type uint8;
        description "Trust";
      }
    }  // grouping IPV4-DHCPD-SNOOP-PROFILE

    grouping IPV4-DHCPD-SNOOP-STATS-INFO {
      description
        "ipv4 dhcpd snoop stats info";
      leaf snoop-stats-timestamp {
        type uint32;
        description "Snoop Stats timestamp";
      }
    }  // grouping IPV4-DHCPD-SNOOP-STATS-INFO

    grouping IPV4-DHCPD-SNOOP-BINDING-STATISTICS {
      description
        "ipv4 dhcpd snoop binding statistics";
      leaf snoop-binding-total {
        type uint32;
        description
          "Total number of snoop bindings";
      }

      leaf snoop-binding-timestamp {
        type uint32;
        description
          "Snoop binding timestamp";
      }
    }  // grouping IPV4-DHCPD-SNOOP-BINDING-STATISTICS

    grouping IPV4-DHCPD-SNOOP-BINDING {
      description
        "ipv4 dhcpd snoop binding entry";
      leaf snoop-binding-ch-addr {
        type yang:hex-string;
        description
          "DHCP client MAC address";
      }

      leaf snoop-binding-ch-addr-len {
        type uint8;
        description
          "DHCP client MAC address length";
      }

      leaf snoop-binding-i-addr {
        type inet:ipv4-address;
        description "DHCP iaddr";
      }

      leaf snoop-binding-client-id {
        type yang:hex-string;
        description "DHCP client id";
      }

      leaf snoop-binding-client-id-len {
        type uint8;
        description "DHCP client id len";
      }

      leaf snoop-binding-state {
        type uint8;
        description "DHCP sm state";
      }

      leaf snoop-binding-lease {
        type uint32;
        description "DHCP lease time";
      }

      leaf snoop-binding-lease-start-time {
        type uint32;
        description "DHCP lease start time";
      }

      leaf snoop-binding-profile-name {
        type string {
          length "0..65";
        }
        description "DHCP profile name";
      }

      leaf snoop-bindng-interface-name {
        type string {
          length "0..321";
        }
        description
          "DHCP interface to client";
      }

      leaf snoop-binding-bridge-name {
        type string {
          length "0..74";
        }
        description "DHCP L2 bridge name";
      }
    }  // grouping IPV4-DHCPD-SNOOP-BINDING
  }  // submodule Cisco-IOS-XR-ipv4-dhcpd-oper-sub1