module Cisco-IOS-XR-ipv4-dhcpd-cfg {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-ipv4-dhcpd-cfg";

    prefix ipv4-dhcpd-cfg;

    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 module contains a collection of YANG definitions
     for Cisco IOS-XR ipv4-dhcpd package configuration.
     
     This module contains definitions
     for the following management objects:
       ipv4-dhcpd: DHCP IPV4 configuration
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-12-15" {
      description
        "Added interface level remote-id configuration to intake ASCII/Hex values.
       2020-08-15
         Added insert-bootfile option.
       2020-07-20
         Added IPoE DHCP CLI to enable option82 in release message.
       2020-06-15
         Added IPoE DHCP client keep subsIntf on new discover CLI.
       2020-06-14
         Added IPoE DHCP client reboot interval config.
       2020-03-31
         Interface vlan-intf session-limit configuration added.
       2020-03-26
         CNBNG profile cfg added.";
    }

    revision "2019-10-18" {
      description
        "Interface remote-id configuration made optional.";
    }

    revision "2019-05-31" {
      description
        "Added interface level remote-id configuration.";
    }

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

    revision "2018-10-24" {
      description "Fixed remote id mask.";
    }

    revision "2017-09-30" {
      description
        "Ensure propagation of MDA mandatory state to YANG model.";
    }

    revision "2017-05-01" {
      description
        "Fixing backward compatibility error in module.";
    }

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

    semver:module-version "1.2.0";
    semver:module-version "1.1.0";
    semver:module-version "1.0.0";

    typedef Ipv4-match-default-mode {
      type enumeration {
        enum "server" {
          value 3;
          description "Server";
        }
      }
      description "Ipv4 match default mode";
    }

    typedef Ipv4dhcpd-client-id {
      type uint32 {
        range "0..4294967295";
      }
      description "Ipv4dhcpd client id";
    }

    typedef Dhcpv4-match-option {
      type enumeration {
        enum "60/60" {
          value 60;
          description "Vendor class ID";
        }
        enum "77/77" {
          value 77;
          description "77 User class";
        }
        enum "124/124" {
          value 124;
          description
            "Vendor identifying class";
        }
        enum "125/125" {
          value 125;
          description
            "Vendor specific information";
        }
      }
      description "Dhcpv4 match option";
    }

    typedef Ipv4dhcpd-layer {
      type enumeration {
        enum "layer2" {
          value 2;
          description "Layer2";
        }
        enum "layer3" {
          value 3;
          description "Layer3";
        }
      }
      description "Ipv4dhcpd layer";
    }

    typedef Dhcpv4-limit-lease1 {
      type enumeration {
        enum "interface" {
          value 1;
          description "Interface";
        }
        enum "circuit-id" {
          value 2;
          description "Circuit ID";
        }
        enum "remote-id" {
          value 3;
          description "Remote ID";
        }
        enum "circuit-id-remote-id" {
          value 4;
          description "Circuit ID Remote ID";
        }
      }
      description "Dhcpv4 limit lease1";
    }

    typedef Ipv4dhcpd-relay-giaddr-policy {
      type enumeration {
        enum "replace" {
          value 1;
          description "Replace";
        }
        enum "drop" {
          value 2;
          description "Drop";
        }
      }
      description
        "Ipv4dhcpd relay giaddr policy";
    }

    typedef Matchoption {
      type enumeration {
        enum "circuitid" {
          value 1;
          description
            "Match circuit id of option 82 Relay-agent
           specific class";
        }
        enum "remoteid" {
          value 2;
          description
            "Match remote id of option 82 Relay-agent
           specific class";
        }
        enum "60" {
          value 60;
          description
            "Match option 60 vendor class id";
        }
        enum "77" {
          value 77;
          description
            "Match option 77 user class";
        }
        enum "124" {
          value 124;
          description
            "Match option 124 vendor-identifying vendor
           class";
        }
        enum "125" {
          value 125;
          description
            "Match option 125 vendor-indentifying
           vendor-specific info";
        }
      }
      description "Matchoption";
    }

    typedef Ipv4dhcpd-relay-info-option-remote-id {
      type enumeration {
        enum "mac-address" {
          value 1;
          description "MacAddress";
        }
        enum "hex" {
          value 2;
          description "Hex Format String";
        }
        enum "ascii" {
          value 3;
          description "Ascii Format String";
        }
      }
      description
        "Ipv4dhcpd relay info option remote id";
    }

    typedef Ipv4dhcpd-giaddr-policy {
      type enumeration {
        enum "giaddr-policy-keep" {
          value 0;
          description "Giaddr Policy Keep";
        }
      }
      description "Ipv4dhcpd giaddr policy";
    }

    typedef Lease-limit-value {
      type enumeration {
        enum "per-interface" {
          value 1;
          description
            "Insert the limit lease type interface";
        }
        enum "per-circuit-id" {
          value 2;
          description
            "Insert the limit lease type circuit-id";
        }
        enum "per-remote-id" {
          value 3;
          description
            "Insert the limit lease type remote-id";
        }
      }
      description "Lease limit value";
    }

    typedef Dhcpv4-auth-username {
      type enumeration {
        enum "auth-username-mac" {
          value 1;
          description
            "Authentication Username formating mac";
        }
        enum "auth-username-giaddr" {
          value 2;
          description
            "Authentication Username formating giaddr";
        }
      }
      description "Dhcpv4 auth username";
    }

    typedef Proxy-action {
      type enumeration {
        enum "allow" {
          value 0;
          description
            "Allow vendor specific DHCP Discover";
        }
        enum "drop" {
          value 1;
          description
            "Drop vendor specific DHCP Discover";
        }
        enum "relay" {
          value 2;
          description
            "Relay vendor-id specific DHCP packets unaltered";
        }
      }
      description "Proxy action";
    }

    typedef Ipv4dhcpd-broadcast-flag-policy {
      type enumeration {
        enum "ignore" {
          value 0;
          description "Ignore";
        }
        enum "check" {
          value 1;
          description "check";
        }
        enum "unicast-always" {
          value 2;
          description "Unicast always";
        }
      }
      description
        "Ipv4dhcpd broadcast flag policy";
    }

    typedef Ipv4-mode-class-mode {
      type enumeration {
        enum "server" {
          value 3;
          description "Server";
        }
        enum "proxy" {
          value 4;
          description "Proxy";
        }
      }
      description "Ipv4 mode class mode";
    }

    typedef Base-action {
      type enumeration {
        enum "allow" {
          value 0;
          description
            "Allow vendor specific DHCP Discover";
        }
        enum "drop" {
          value 1;
          description
            "Drop vendor specific DHCP Discover";
        }
      }
      description "Base action";
    }

    typedef Dhcpv4-limit-lease {
      type uint32 {
        range "1..240000";
      }
      description "Dhcpv4 limit lease";
    }

    typedef Ipv4dhcpd-mode {
      type enumeration {
        enum "base" {
          value 0;
          description "Base";
        }
        enum "relay" {
          value 1;
          description "Relay";
        }
        enum "snoop" {
          value 2;
          description "Snoop";
        }
        enum "server" {
          value 3;
          description "Server";
        }
        enum "proxy" {
          value 4;
          description "Proxy";
        }
        enum "base2" {
          value 5;
          description "Base2";
        }
        enum "cnbng" {
          value 7;
          description "Cnbng";
        }
      }
      description "Ipv4dhcpd mode";
    }

    typedef Matchaction {
      type enumeration {
        enum "allow" {
          value 0;
          description "Allow DHCP Discover";
        }
        enum "drop" {
          value 1;
          description "Drop DHCP Discover";
        }
      }
      description "Matchaction";
    }

    typedef Policy {
      type enumeration {
        enum "ignore" {
          value 0;
          description
            "Ignore the broadcast policy";
        }
        enum "check" {
          value 1;
          description
            "Check for broadcast flag";
        }
        enum "unicastalways" {
          value 2;
          description
            "Always Unicast the reply";
        }
      }
      description "Policy";
    }

    typedef Ipv4dhcpd-relay-info-optionvpn-mode {
      type enumeration {
        enum "rfc" {
          value 0;
          description "RFC";
        }
        enum "cisco" {
          value 1;
          description "Cisco";
        }
      }
      description
        "Ipv4dhcpd relay info optionvpn mode";
    }

    typedef Ipv4dhcpd-fmt {
      type enumeration {
        enum "no-format" {
          value 0;
          description "Not a Format String";
        }
        enum "hex" {
          value 1;
          description "Hex Format String";
        }
        enum "ascii" {
          value 2;
          description "Ascii Format String";
        }
        enum "extended" {
          value 3;
          description
            "Extended Format String";
        }
      }
      description "Ipv4dhcpd fmt";
    }

    typedef Ipv4dhcpd-relay-info-option-authenticate {
      type enumeration {
        enum "received" {
          value 0;
          description "Received";
        }
        enum "inserted" {
          value 1;
          description "Inserted";
        }
      }
      description
        "Ipv4dhcpd relay info option authenticate";
    }

    typedef Ipv4dhcpd-relay-info-option-policy {
      type enumeration {
        enum "replace" {
          value 0;
          description "Replace";
        }
        enum "keep" {
          value 1;
          description "Keep";
        }
        enum "drop" {
          value 2;
          description "Drop";
        }
        enum "encapsulate" {
          value 3;
          description "Encapsulate";
        }
      }
      description
        "Ipv4dhcpd relay info option policy";
    }

    typedef Ipv4dhcpd-fmt-specifier {
      type enumeration {
        enum "physical-chassis" {
          value 1;
          description "Physical chassis";
        }
        enum "physical-slot" {
          value 2;
          description "Physical slot";
        }
        enum "physical-sub-slot" {
          value 3;
          description "Physical sub-slot";
        }
        enum "physical-port" {
          value 4;
          description "Physical port";
        }
        enum "physical-sub-port" {
          value 5;
          description "Physical sub-port";
        }
        enum "inner-vlan-id" {
          value 6;
          description "Inner VLAN ID";
        }
        enum "outer-vlan-id" {
          value 7;
          description "Outer VLAN ID";
        }
        enum "l2-interface" {
          value 8;
          description "L2 Interface";
        }
        enum "l3-interface" {
          value 9;
          description "L3 Interface";
        }
        enum "host-name" {
          value 10;
          description "Hostname";
        }
      }
      description "Ipv4dhcpd fmt specifier";
    }

    typedef Mac-mismatch-action {
      type enumeration {
        enum "forward" {
          value 0;
          description "Forward";
        }
        enum "drop" {
          value 1;
          description "Drop";
        }
      }
      description "Mac mismatch action";
    }

    grouping OPTION-CODE-TABLE {
      description
        "Common node of server, class";
      container option-codes {
        description "Table of OptionCode";
        list option-code {
          key "option-code";
          description "DHCP option code";
          leaf option-code {
            type uint32 {
              range "0..255";
            }
            description "DHCP option code";
          }

          leaf ascii-string {
            type string;
            description "ASCII string";
          }

          leaf hex-string {
            type string;
            description "Hexadecimal string";
          }

          leaf force-insert {
            type uint32;
            description
              "Set constant integer";
          }

          leaf-list ip-address {
            type inet:ipv4-address-no-zone;
            max-elements 8;
            description
              "Server's IP address";
          }
        }  // list option-code
      }  // container option-codes
    }  // grouping OPTION-CODE-TABLE

    container ipv4-dhcpd {
      presence
        "Indicates a ipv4-dhcpd node is configured.";
      description "DHCP IPV4 configuration";
      container client-reboot-interval {
        description
          "Configure IPoE DHCP client reboot interval";
        leaf client-reboot-interval {
          type uint32 {
            range "10..30";
          }
          description
            "Client reboot time value";
        }

        leaf max-client-reboot-interval {
          type uint32 {
            range "10..300";
          }
          description
            "Client Max reboot time value";
        }
      }  // container client-reboot-interval

      container vrfs {
        description "VRF Table";
        list vrf {
          key "vrf-name";
          description "VRF table";
          container profile {
            presence
              "Indicates a profile node is configured.";
            description
              "Profile name and mode";
            leaf vrf-profile-name {
              type string;
              mandatory true;
              description "Profile name";
            }

            leaf mode {
              type Ipv4dhcpd-mode;
              mandatory true;
              description "Dhcp mode";
            }
          }  // container profile

          leaf vrf-name {
            type xr:Cisco-ios-xr-string;
            description "VRF Name";
          }
        }  // list vrf
      }  // container vrfs

      container profiles {
        description
          "DHCP IPV4 Profile Table";
        list profile {
          key "profile-name";
          description "DHCP IPV4 Profile";
          container modes {
            description
              "DHCP IPV4 Profile modes";
            list mode {
              key "mode";
              description
                "DHCP IPV4 Profile mode";
              container snoop {
                description
                  "DHCP Snoop profile";
                container relay-information-option {
                  description
                    "DHCP Snoop profile";
                  container remote-id {
                    description
                      "Enter remote-id value";
                    leaf format-type {
                      type uint32 {
                        range "1..2";
                      }
                      description
                        "Format type, 1. Hex 2. ASCII";
                    }

                    leaf remote-id-value {
                      type string;
                      description
                        "Enter remote-id value";
                    }
                  }  // container remote-id

                  leaf insert {
                    type empty;
                    description
                      "Insert Relay Agent Information circuit ID
                     and remote ID suboptions in client request";
                  }

                  leaf allow-untrusted {
                    type empty;
                    description
                      "Forward untrusted packets";
                  }

                  leaf policy {
                    type Ipv4dhcpd-relay-info-option-policy;
                    description
                      "Relay information option policy";
                  }
                }  // container relay-information-option

                leaf trusted {
                  type empty;
                  description
                    "Trusted sources";
                }
              }  // container snoop

              container base {
                presence
                  "Indicates a base node is configured.";
                description
                  "DHCP Base Profile";
                container default-profile {
                  description
                    "Enable the default profile";
                  leaf profile-name {
                    type xr:Cisco-ios-xr-string {
                      length "1..64";
                    }
                    description
                      "Profile name";
                  }

                  leaf profile-mode {
                    type uint32;
                    description "none";
                  }
                }  // container default-profile

                container match {
                  description
                    "Insert match keyword";
                  container option-filters {
                    description
                      "Table of Option";
                    list option-filter {
                      key "matchoption pattern format";
                      description
                        "Specify match option";
                      leaf option-action {
                        type Base-action;
                        description
                          "Vendor action";
                      }

                      leaf matchoption {
                        type uint32;
                        description
                          "Match option 60";
                      }

                      leaf pattern {
                        type xr:Cisco-ios-xr-string {
                          length "1..64";
                        }
                        description
                          "Enter hex pattern string";
                      }

                      leaf format {
                        type uint32;
                        description
                          "Set constant integer";
                      }
                    }  // list option-filter
                  }  // container option-filters

                  container def-options {
                    description
                      "Table of Option";
                    list def-option {
                      key "def-matchoption";
                      description
                        "Specify match option";
                      leaf def-matchoption {
                        type uint32;
                        description
                          "Match option 60";
                      }

                      leaf def-matchaction {
                        type Base-action;
                        mandatory true;
                        description
                          "Vendor action";
                      }
                    }  // list def-option
                  }  // container def-options
                }  // container match

                container base-relay-opt {
                  description
                    "Insert Relay Agent Information circuit ID
                   and remote ID suboptions in client request";
                  leaf remote-id {
                    type string {
                      length "1..256";
                    }
                    description
                      "Enter remote-id value";
                  }

                  leaf authenticate {
                    type uint32;
                    description
                      "Specify Relay Agent Information Option
                     authenticate";
                  }
                }  // container base-relay-opt

                container dhcp-to-aaa {
                  description
                    "Enable to provide the list of options need
                   to send to aaa";
                  container base-option {
                    description
                      "option type";
                    container list {
                      description
                        "List of options";
                      leaf option-all {
                        type uint32;
                        description
                          "option all";
                      }

                      leaf-list option {
                        type uint32 {
                          range "1..255";
                        }
                        max-elements 12;
                        description
                          "List of options";
                      }
                    }  // container list
                  }  // container base-option
                }  // container dhcp-to-aaa

                container base-match {
                  description
                    "Insert match keyword";
                  container options {
                    description
                      "Specify match option";
                    list option {
                      key "opt60 opt60-hex-str format";
                      description "none";
                      container option-profile {
                        description
                          "Enter a profile";
                        leaf profile-name {
                          type xr:Cisco-ios-xr-string {
                            length "1..64";
                          }
                          description
                            "Profile name";
                        }

                        leaf profile-mode {
                          type uint32;
                          description "none";
                        }
                      }  // container option-profile

                      leaf opt60 {
                        type uint32;
                        description "none";
                      }

                      leaf opt60-hex-str {
                        type xr:Cisco-ios-xr-string;
                        description
                          "Enter hex pattern string";
                      }

                      leaf format {
                        type uint32;
                        description
                          "Set constant integer";
                      }
                    }  // list option
                  }  // container options

                  container mode-classes {
                    description
                      "Table of ModeClass";
                    list mode-class {
                      key "class-name";
                      description
                        "Specify PPP/IPoE class option";
                      container profile {
                        description
                          "Enter proxy or server profile";
                        leaf profile-name {
                          type xr:Cisco-ios-xr-string {
                            length "1..64";
                          }
                          description
                            "Profile name";
                        }

                        leaf mode {
                          type Ipv4-mode-class-mode;
                          description
                            "Specify mode";
                        }
                      }  // container profile

                      leaf class-name {
                        type xr:Cisco-ios-xr-string {
                          length "1..64";
                        }
                        description
                          "Class name";
                      }
                    }  // list mode-class
                  }  // container mode-classes
                }  // container base-match

                container match-default {
                  description
                    "Default match option";
                  container profile {
                    description
                      "Enter server profile";
                    leaf profile-name {
                      type xr:Cisco-ios-xr-string {
                        length "1..64";
                      }
                      description
                        "Profile name";
                    }

                    leaf default-mode {
                      type Ipv4-match-default-mode;
                      description
                        "Specify mode";
                    }
                  }  // container profile
                }  // container match-default

                leaf enable {
                  type empty;
                  mandatory true;
                  description
                    "Enable the DHCP IPv4 Base Profile";
                }
              }  // container base

              container server {
                presence
                  "Indicates a server node is configured.";
                description
                  "DHCP Server profile";
                container server-id-check {
                  description
                    "Validate server ID check";
                  leaf check {
                    type empty;
                    description
                      "specify server-id-check disable";
                  }
                }  // container server-id-check

                container lease-limit {
                  description
                    "Specify limit lease";
                  leaf lease-limit-value {
                    type Lease-limit-value;
                    description
                      "Configure Lease limit value";
                  }

                  leaf range {
                    type uint32 {
                      range "1..240000";
                    }
                    description
                      "Value of limit lease count in Decimal";
                  }
                }  // container lease-limit

                container requested-ip-address {
                  description
                    "Validate Requested IP Address";
                  leaf check {
                    type empty;
                    description
                      "specify requested-ip-address-check disable";
                  }
                }  // container requested-ip-address

                container aaa-server {
                  description
                    "Enable aaa dhcp option force-insert";
                  container dhcp-option {
                    description
                      "Enable aaa dhcp option force-insert";
                    leaf force-insert {
                      type empty;
                      description
                        "Enable aaa dhcp option force-insert";
                    }
                  }  // container dhcp-option
                }  // container aaa-server

                container default-routers {
                  description
                    "default routers";
                  leaf-list default-router {
                    type inet:ipv4-address-no-zone;
                    max-elements 8;
                    description
                      "Router's IP address";
                  }
                }  // container default-routers

                container delete-binding-on-discover {
                  description
                    "Delete binding on receiving discover";
                  leaf disable {
                    type empty;
                    description
                      "Disable delete binding on discover";
                  }
                }  // container delete-binding-on-discover

                container net-bios-name-servers {
                  description
                    "NetBIOS name servers";
                  leaf-list net-bios-name-server {
                    type inet:ipv4-address-no-zone;
                    max-elements 8;
                    description
                      "NetBIOSNameServer's IP address";
                  }
                }  // container net-bios-name-servers

                container match {
                  description
                    "Insert match keyword";
                  container option-defaults {
                    description
                      "Table of OptionDefault";
                    list option-default {
                      key "matchoption";
                      description
                        "Specify match option";
                      leaf matchoption {
                        type Matchoption;
                        description
                          "Match option 60";
                      }

                      leaf matchaction {
                        type Matchaction;
                        mandatory true;
                        description
                          "Vendor action";
                      }
                    }  // list option-default
                  }  // container option-defaults

                  container options {
                    description
                      "Table of Option";
                    list option {
                      key "matchoption pattern format";
                      description
                        "Specify match option";
                      leaf matchoption {
                        type Matchoption;
                        description
                          "Match option 60";
                      }

                      leaf pattern {
                        type xr:Cisco-ios-xr-string {
                          length "1..64";
                        }
                        description
                          "Enter hex pattern string";
                      }

                      leaf format {
                        type uint32;
                        description
                          "Set constant integer";
                      }

                      leaf matchaction {
                        type Matchaction;
                        mandatory true;
                        description
                          "Vendor action";
                      }
                    }  // list option
                  }  // container options
                }  // container match

                container broadcast-flag {
                  description "None";
                  leaf policy {
                    type Policy;
                    description
                      "Specify broadcast flag policy";
                  }
                }  // container broadcast-flag

                container session {
                  description
                    "Change sessions configuration";
                  container throttle-type {
                    description
                      "Throttle DHCP sessions based on MAC
                     address";
                    container mac-throttle {
                      description
                        "Throttle DHCP sessions from any one MAC
                       address";
                      leaf num-discover {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Number of discovers at which to throttle";
                      }

                      leaf num-request {
                        type uint32 {
                          range "1..100";
                        }
                        units "second";
                        description
                          "Throttle request period (in secs)";
                      }

                      leaf num-block {
                        type uint32 {
                          range "1..100";
                        }
                        units "second";
                        description
                          "Throttle blocking period (in secs)";
                      }
                    }  // container mac-throttle
                  }  // container throttle-type
                }  // container session

                container classes {
                  description
                    "Table of Class";
                  list class {
                    key "class-name";
                    description
                      "Create or enter server profile class";
                    container default-routers {
                      description
                        "default routers";
                      leaf-list default-router {
                        type inet:ipv4-address-no-zone;
                        max-elements 8;
                        description
                          "Router's IP address";
                      }
                    }  // container default-routers

                    container net-bios-name-servers {
                      description
                        "NetBIOS name servers";
                      leaf-list net-bios-name-server {
                        type inet:ipv4-address-no-zone;
                        max-elements 8;
                        description
                          "NetBIOSNameServer's IP address";
                      }
                    }  // container net-bios-name-servers

                    container class-match {
                      description
                        "Insert match keyword";
                      container class-options {
                        description
                          "Table of Class-Option";
                        list class-option {
                          key "matchoption";
                          description
                            "Specify match option";
                          leaf matchoption {
                            type Matchoption;
                            description
                              "Match options";
                          }

                          leaf pattern {
                            type string {
                              length "1..64";
                            }
                            description
                              "Enter hex pattern string";
                          }

                          leaf bit-mask {
                            type string {
                              length "1..64";
                            }
                            description
                              "Enter bit mask pattern string";
                          }
                        }  // list class-option
                      }  // container class-options

                      leaf l2-interface {
                        type xr:Interface-name;
                        description
                          "Specify match l2-interface";
                      }

                      leaf vrf {
                        type xr:Cisco-ios-xr-string {
                          length "1..32";
                        }
                        description
                          "Specify match VRF";
                      }
                    }  // container class-match

                    container lease {
                      description "lease";
                      leaf infinite {
                        type string;
                        description
                          "Set string";
                      }

                      leaf days {
                        type uint32 {
                          range "0..365";
                        }
                        units "day";
                        description "Days";
                      }

                      leaf hours {
                        type uint32 {
                          range "0..23";
                        }
                        units "hour";
                        description "Hours";
                      }

                      leaf minutes {
                        type uint32 {
                          range "0..59";
                        }
                        units "minute";
                        description
                          "Minutes";
                      }
                    }  // container lease

                    container netbios-node-type {
                      description
                        "NetBIOS node type";
                      leaf broadcast-node {
                        type string;
                        description
                          "Set string";
                      }

                      leaf hybrid-node {
                        type string;
                        description
                          "Set string";
                      }

                      leaf mixed-node {
                        type string;
                        description
                          "Set string";
                      }

                      leaf peer-to-peer-node {
                        type string;
                        description
                          "Set string";
                      }

                      leaf hexadecimal {
                        type xr:Hex-integer;
                        description
                          "Hexadecimal number";
                      }
                    }  // container netbios-node-type

                    container dns-servers {
                      description
                        "DNS servers";
                      leaf-list dns-server {
                        type inet:ipv4-address-no-zone;
                        max-elements 8;
                        description
                          "DNS Server's IP address";
                      }
                    }  // container dns-servers

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

                    leaf pool {
                      type string;
                      description
                        "Specify the pool";
                    }

                    leaf enable {
                      type empty;
                      description
                        "Enable Create or enter server profile
                       class. Deletion of this object also
                       causes deletion of all associated objects
                       under Class.";
                    }

                    leaf domain-name {
                      type xr:Cisco-ios-xr-string {
                        length "1..256";
                      }
                      description
                        "Domain name";
                    }

                    leaf boot-filename {
                      type xr:Cisco-ios-xr-string {
                        length "1..128";
                      }
                      description
                        "Boot Filename";
                    }

                    leaf next-server {
                      type inet:ipv4-address-no-zone;
                      description
                        "Configure the tftp-server IP to be used
                       by the client";
                    }

                    leaf class-name {
                      type xr:Cisco-ios-xr-string {
                        length "1..128";
                      }
                      description
                        "class name";
                    }

                    uses OPTION-CODE-TABLE;
                  }  // list class
                }  // container classes

                container relay {
                  description
                    "Specify Relay Agent Information Option
                   configuration";
                  leaf authenticate {
                    type uint32;
                    description
                      "Specify Relay Agent Information Option
                     authenticate";
                  }
                }  // container relay

                container lease {
                  description "lease";
                  leaf infinite {
                    type string;
                    description "Set string";
                  }

                  leaf days {
                    type uint32 {
                      range "0..365";
                    }
                    units "day";
                    description "Days";
                  }

                  leaf hours {
                    type uint32 {
                      range "0..23";
                    }
                    units "hour";
                    description "Hours";
                  }

                  leaf minutes {
                    type uint32 {
                      range "0..59";
                    }
                    units "minute";
                    description "Minutes";
                  }
                }  // container lease

                container netbios-node-type {
                  description
                    "NetBIOS node type";
                  leaf broadcast-node {
                    type string;
                    description "Set string";
                  }

                  leaf hybrid-node {
                    type string;
                    description "Set string";
                  }

                  leaf mixed-node {
                    type string;
                    description "Set string";
                  }

                  leaf peer-to-peer-node {
                    type string;
                    description "Set string";
                  }

                  leaf hexadecimal {
                    type xr:Hex-integer;
                    description
                      "Hexadecimal number";
                  }
                }  // container netbios-node-type

                container dns-servers {
                  description "DNS servers";
                  leaf-list dns-server {
                    type inet:ipv4-address-no-zone;
                    max-elements 8;
                    description
                      "DNS Server's IP address";
                  }
                }  // container dns-servers

                container dhcp-to-aaa {
                  description
                    "Enable to provide the list of options need
                   to send to aaa";
                  container option {
                    description
                      "option type";
                    container list {
                      description
                        "List of options";
                      leaf option-all {
                        type uint32;
                        description
                          "Set constant integer";
                      }

                      leaf-list option-number {
                        type uint32;
                        max-elements 12;
                        description
                          "Option number";
                      }
                    }  // container list
                  }  // container option
                }  // container dhcp-to-aaa

                leaf server-allow-move {
                  type empty;
                  description
                    "Allow dhcp subscriber move";
                }

                leaf enable {
                  type empty;
                  mandatory true;
                  description
                    "DHCP IPV4 profile mode enable";
                }

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

                leaf insert-bootfile {
                  type empty;
                  description
                    "Force insert bootfile name";
                }

                leaf pool {
                  type string {
                    length "1..64";
                  }
                  description
                    "Specify the Pool name";
                }

                leaf domain-name {
                  type xr:Cisco-ios-xr-string {
                    length "1..256";
                  }
                  description "Domain name";
                }

                leaf secure-arp {
                  type empty;
                  description
                    "Enable Secure Arp";
                }

                leaf arp-instal-skip-stdalone {
                  type empty;
                  description
                    "Skip ARP installation for standalone
                   sessions";
                }

                leaf boot-filename {
                  type xr:Cisco-ios-xr-string {
                    length "1..128";
                  }
                  description
                    "Boot Filename";
                }

                leaf enable-session-limit {
                  type empty;
                  description
                    "Enable vlan or interface session limit";
                }

                leaf next-server {
                  type inet:ipv4-address-no-zone;
                  description
                    "Configure the tftp-server IP to be used by
                   the client";
                }

                uses OPTION-CODE-TABLE;
              }  // container server

              container relay {
                description
                  "DHCP Relay profile";
                container gi-addr-policy {
                  presence
                    "Indicates a gi-addr-policy node is configured.";
                  description
                    "GIADDR policy";
                  leaf policy {
                    type Ipv4dhcpd-relay-giaddr-policy;
                    mandatory true;
                    description
                      "GIADDR policy";
                  }
                }  // container gi-addr-policy

                container vrfs {
                  description
                    "VRF Helper Addresses";
                  list vrf {
                    key "vrf-name";
                    description "VRF Name";
                    container helper-addresses {
                      description
                        "Helper Addresses";
                      list helper-address {
                        key "ip-address";
                        description
                          "Helper Address";
                        leaf ip-address {
                          type inet:ipv4-address-no-zone;
                          description
                            "IPV4 Address";
                        }

                        leaf enable {
                          type empty;
                          description
                            "Enable helper - deprecated";
                        }

                        leaf gateway-address {
                          type inet:ipv4-address-no-zone;
                          description
                            "GatewayAddress";
                        }
                      }  // list helper-address
                    }  // container helper-addresses

                    leaf vrf-name {
                      type xr:Cisco-ios-xr-string;
                      description "VRF Name";
                    }
                  }  // list vrf
                }  // container vrfs

                container relay-information-option {
                  description
                    "Relay agent information option";
                  container remote-id {
                    description
                      "Enter remote-id value";
                    leaf format-type {
                      type uint32 {
                        range "1..2";
                      }
                      description
                        "Format type, 1. Hex 2. ASCII";
                    }

                    leaf remote-id-value {
                      type string;
                      description
                        "Enter remote-id value";
                    }
                  }  // container remote-id

                  leaf vpn-mode {
                    type Ipv4dhcpd-relay-info-optionvpn-mode;
                    description "VPN Mode";
                  }

                  leaf subscriber-id {
                    type string;
                    description
                      "Subscriber ID";
                  }

                  leaf allow-in-release-msg {
                    type empty;
                    description
                      "handle option82 in release message";
                  }

                  leaf insert {
                    type empty;
                    description
                      "Insert Relay Agent Information circuit ID
                     and remote ID suboptions in client
                     requests";
                  }

                  leaf check {
                    type empty;
                    description
                      "Check Relay Agent Information Option in
                     server reply";
                  }

                  leaf vpn {
                    type empty;
                    description
                      "Insert VPN options";
                  }

                  leaf allow-untrusted {
                    type empty;
                    description
                      "Forward untrusted packets";
                  }

                  leaf policy {
                    type Ipv4dhcpd-relay-info-option-policy;
                    description
                      "Relay information option policy";
                  }
                }  // container relay-information-option

                container broadcast-policy {
                  presence
                    "Indicates a broadcast-policy node is configured.";
                  description
                    "Broadcast Flag policy";
                  leaf policy {
                    type Ipv4dhcpd-broadcast-flag-policy;
                    mandatory true;
                    description
                      "Broadcast flag policy";
                  }
                }  // container broadcast-policy

                leaf mac-mismatch-action {
                  type Mac-mismatch-action;
                  description
                    "Action to take if L2 header source Mac and
                   dhcp header mac address don't match";
                }
              }  // container relay

              container proxy {
                presence
                  "Indicates a proxy node is configured.";
                description
                  "DHCP proxy profile";
                container giaddr {
                  presence
                    "Indicates a giaddr node is configured.";
                  description
                    "Specify gateway address policy";
                  leaf policy {
                    type Ipv4dhcpd-giaddr-policy;
                    mandatory true;
                    description
                      "Gateway address policy";
                  }
                }  // container giaddr

                container classes {
                  description
                    "DHCP class table";
                  list class {
                    key "class-name";
                    description "DHCP class";
                    container match {
                      description
                        "Match option";
                      container option {
                        description
                          "Match option";
                        leaf option-type {
                          type Dhcpv4-match-option;
                          description
                            "Match option";
                        }

                        leaf pattern {
                          type string;
                          description
                            "Hex pattern string";
                        }

                        leaf bit-mask {
                          type string;
                          description
                            "Bit mask pattern";
                        }
                      }  // container option

                      leaf vrf {
                        type string;
                        description
                          "Match VRF name";
                      }
                    }  // container match

                    container vrfs {
                      description
                        "List of VRFs";
                      list vrf {
                        key "vrf-name";
                        description
                          "VRF name";
                        container helper-addresses {
                          description
                            "Helper addresses";
                          list helper-address {
                            key "server-address";
                            description
                              "Helper address";
                            leaf server-address {
                              type inet:ipv4-address-no-zone;
                              description
                                "IPv4 address";
                            }

                            leaf gateway-address {
                              type inet:ipv4-address-no-zone;
                              mandatory
                                true;
                              description
                                "Gateway address";
                            }
                          }  // list helper-address
                        }  // container helper-addresses

                        leaf vrf-name {
                          type xr:Cisco-ios-xr-string;
                          description
                            "VRF name";
                        }
                      }  // list vrf
                    }  // container vrfs

                    leaf enable {
                      type empty;
                      mandatory true;
                      description
                        "Enable the DHCP IPV4 proxy class";
                    }

                    leaf class-name {
                      type xr:Cisco-ios-xr-string;
                      description
                        "Class name";
                    }
                  }  // list class
                }  // container classes

                container auth-username {
                  presence
                    "Indicates a auth-username node is configured.";
                  description
                    "Authentication Username formating";
                  leaf arg1 {
                    type Dhcpv4-auth-username;
                    mandatory true;
                    description
                      "Username Formatting first argument ";
                  }

                  leaf arg2 {
                    type Dhcpv4-auth-username;
                    description
                      "Username Formatting second argument ";
                  }
                }  // container auth-username

                container relay-information {
                  description
                    "Relay agent information option";
                  leaf option {
                    type empty;
                    description
                      "Insert relay rgent information circuit ID
                     and remote ID suboptions in client
                     requests";
                  }

                  leaf vpn {
                    type empty;
                    description
                      "Insert VPN options";
                  }

                  leaf allow-untrusted {
                    type empty;
                    description
                      "Forward untrusted packets";
                  }

                  leaf circuit-id {
                    type empty;
                    description
                      "Insert Circuit-id sub-option";
                  }

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

                  leaf vpn-mode {
                    type Ipv4dhcpd-relay-info-optionvpn-mode;
                    description "VPN Mode";
                  }

                  leaf remote-id-xr {
                    type empty;
                    description
                      "Insert Remote-id sub-option";
                  }

                  leaf remote-id-suppress {
                    type empty;
                    description
                      "Suppress Remote ID";
                  }

                  leaf check {
                    type empty;
                    description
                      "Check relay agent information option in
                     server reply";
                  }

                  leaf remote-id {
                    type string;
                    description "Remote ID";
                  }

                  leaf authenticate {
                    type Ipv4dhcpd-relay-info-option-authenticate;
                    description
                      "Relay information option authenticate";
                  }
                }  // container relay-information

                container dhcp-to-aaa {
                  description
                    "Enable to provide the list of options need
                   to send to aaa";
                  container option {
                    description
                      "option type";
                    container list {
                      description
                        "List of options";
                      leaf option-all {
                        type uint32;
                        description
                          "option all";
                      }

                      leaf-list option {
                        type uint32 {
                          range "1..255";
                        }
                        max-elements 12;
                        description
                          "List of options";
                      }
                    }  // container list
                  }  // container option
                }  // container dhcp-to-aaa

                container vrfs {
                  description "List of VRFs";
                  list vrf {
                    key "vrf-name";
                    description "VRF name";
                    container helper-addresses {
                      description
                        "Helper addresses";
                      list helper-address {
                        key "server-address";
                        description
                          "Helper address";
                        leaf server-address {
                          type inet:ipv4-address-no-zone;
                          description
                            "IPv4 address";
                        }

                        leaf gateway-address {
                          type inet:ipv4-address-no-zone;
                          mandatory true;
                          description
                            "Gateway address";
                        }
                      }  // list helper-address
                    }  // container helper-addresses

                    leaf vrf-name {
                      type xr:Cisco-ios-xr-string;
                      description "VRF name";
                    }
                  }  // list vrf
                }  // container vrfs

                container sessions {
                  description
                    "Change sessions configuration";
                  container proxy-throttle-type {
                    description
                      "Throttle DHCP sessions based on MAC
                     address";
                    container proxy-mac-throttle {
                      description
                        "Throttle DHCP sessions from any one MAC
                       address";
                      leaf num-discover {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Number of discovers at which to throttle";
                      }

                      leaf num-request {
                        type uint32 {
                          range "1..100";
                        }
                        units "second";
                        description
                          "Throttle request period (in secs)";
                      }

                      leaf num-block {
                        type uint32 {
                          range "1..100";
                        }
                        units "second";
                        description
                          "Throttle blocking period (in secs)";
                      }
                    }  // container proxy-mac-throttle
                  }  // container proxy-throttle-type
                }  // container sessions

                container limit-lease {
                  presence
                    "Indicates a limit-lease node is configured.";
                  description
                    "Proxy limit lease";
                  leaf limit-type {
                    type Dhcpv4-limit-lease1;
                    mandatory true;
                    description
                      "Lease limit type";
                  }

                  leaf limit-lease-count {
                    type Dhcpv4-limit-lease;
                    mandatory true;
                    description
                      "Limit lease count";
                  }
                }  // container limit-lease

                container lease-proxy {
                  description
                    "DHCPv4 lease proxy";
                  leaf client-lease-time {
                    type uint32 {
                      range
                        "300..4294967295";
                    }
                    description
                      "Specify client lease proxy time";
                  }

                  leaf set-server-options {
                    type empty;
                    description
                      "Set DHCP server sent options in lease
                     proxy generating ACK";
                  }
                }  // container lease-proxy

                container broadcast-flag {
                  presence
                    "Indicates a broadcast-flag node is configured.";
                  description
                    "Specify broadcast flag";
                  leaf policy {
                    type Ipv4dhcpd-broadcast-flag-policy;
                    mandatory true;
                    description
                      "Broadcast flag policy";
                  }
                }  // container broadcast-flag

                container match {
                  description
                    "Insert match keyword";
                  container def-options {
                    description
                      "Table of Option";
                    list def-option {
                      key "def-matchoption";
                      description
                        "Specify match option";
                      leaf def-matchoption {
                        type uint32;
                        description
                          "Match option 60";
                      }

                      leaf def-matchaction {
                        type Proxy-action;
                        mandatory true;
                        description
                          "Vendor action";
                      }
                    }  // list def-option
                  }  // container def-options

                  container option-filters {
                    description
                      "Table of Option";
                    list option-filter {
                      key "matchoption pattern format";
                      description
                        "Specify match option";
                      leaf matchoption {
                        type uint32;
                        description
                          "Match option 60";
                      }

                      leaf pattern {
                        type xr:Cisco-ios-xr-string {
                          length "1..64";
                        }
                        description
                          "Enter hex pattern string";
                      }

                      leaf format {
                        type uint32;
                        description
                          "Set constant integer";
                      }

                      leaf matchaction {
                        type Proxy-action;
                        mandatory true;
                        description
                          "Vendor action";
                      }
                    }  // list option-filter
                  }  // container option-filters
                }  // container match

                leaf handle-discover-in-bound {
                  type empty;
                  description
                    "handle new discover in bound state";
                }

                leaf proxy-allow-move {
                  type empty;
                  description
                    "Allow dhcp subscriber move";
                }

                leaf secure-arp {
                  type empty;
                  description
                    "DHCP IPV4 profile proxy secure-arp enable";
                }

                leaf delayed-authen-proxy {
                  type empty;
                  description
                    "For BNG session, delay the authentication";
                }

                leaf enable {
                  type empty;
                  mandatory true;
                  description
                    "DHCP IPV4 profile mode enable";
                }
              }  // container proxy

              container cnbng {
                presence
                  "Indicates a cnbng node is configured.";
                description
                  "DHCP cnbng profile";
                leaf enable {
                  type empty;
                  mandatory true;
                  description
                    "DHCP IPV4 profile mode enable";
                }
              }  // container cnbng

              leaf enable {
                type empty;
                description
                  "Enable the DHCP IPV4 Profile mode";
              }

              leaf mode {
                type Ipv4dhcpd-mode;
                description
                  "DHCP IPV4 Profile mode";
              }
            }  // list mode
          }  // container modes

          leaf profile-name {
            type xr:Cisco-ios-xr-string;
            description "Profile Name";
          }
        }  // list profile
      }  // container profiles

      container database {
        description
          "Enable DHCP binding database storage to file
         system";
        leaf proxy {
          type empty;
          description
            "Enable DHCP proxy binding database storage to
           file system";
        }

        leaf server {
          type empty;
          description
            "Enable DHCP server binding database storage to
           file system";
        }

        leaf snoop {
          type empty;
          description
            "Enable DHCP snoop binding database storage to
           file system";
        }

        leaf full-write-interval {
          type uint32 {
            range "1..1440";
          }
          default "10";
          description
            "Full file write interval (default 10 minutes)";
        }

        leaf incremental-write-interval {
          type uint32 {
            range "1..1440";
          }
          default "1";
          description
            "Incremental file write interval (default 1
           minutes)";
        }
      }  // container database

      container interfaces {
        description
          "DHCP IPV4 Interface Table";
        list interface {
          key "interface-name";
          description "DHCP IPV4 Interface";
          container proxy-interface {
            description
              "DHCP IPv4 proxy information";
            container dhcp-circuit-id {
              presence
                "Indicates a dhcp-circuit-id node is configured.";
              description "Circuit ID value";
              leaf circuit-id {
                type string;
                mandatory true;
                description
                  "DHCP IPv4 circuit ID value";
              }

              leaf format {
                type Ipv4dhcpd-fmt;
                mandatory true;
                description "Format String";
              }

              leaf argument1 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument2 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument3 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument4 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument5 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument6 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument7 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument8 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument9 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument10 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument11 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument12 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument13 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument14 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument15 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument16 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }
            }  // container dhcp-circuit-id

            leaf proxy-remote-id {
              type Ipv4dhcpd-relay-info-option-remote-id;
              description
                "Insert option 82 remote-id sub-option";
            }

            leaf profile {
              type string;
              description
                "Interface profile name";
            }
          }  // container proxy-interface

          container base-interface {
            description
              "DHCP IPv4 Base profile information";
            container base-dhcp-circuit-id {
              presence
                "Indicates a base-dhcp-circuit-id node is configured.";
              description "Circuit ID value";
              leaf circuit-id {
                type string;
                mandatory true;
                description
                  "DHCP IPv4 circuit ID value";
              }

              leaf format {
                type Ipv4dhcpd-fmt;
                mandatory true;
                description "Format String";
              }

              leaf argument1 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument2 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument3 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument4 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument5 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument6 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument7 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument8 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument9 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument10 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument11 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument12 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument13 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument14 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument15 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument16 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }
            }  // container base-dhcp-circuit-id

            leaf profile {
              type string;
              description
                "Interface profile name";
            }
          }  // container base-interface

          container relay-interface {
            description
              "DHCP IPv4 relay information";
            container relay-dhcp-circuit-id {
              presence
                "Indicates a relay-dhcp-circuit-id node is configured.";
              description "Circuit ID value";
              leaf circuit-id {
                type string;
                mandatory true;
                description
                  "DHCP IPv4 circuit ID value";
              }

              leaf format {
                type Ipv4dhcpd-fmt;
                mandatory true;
                description "Format String";
              }

              leaf argument1 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument2 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument3 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument4 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument5 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument6 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument7 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument8 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument9 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument10 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument11 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument12 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument13 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument14 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument15 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument16 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }
            }  // container relay-dhcp-circuit-id

            leaf relay-remote-id {
              type Ipv4dhcpd-relay-info-option-remote-id;
              description
                "Insert option 82 remote-id sub-option";
            }
          }  // container relay-interface

          container static-mode {
            description
              "Static Table Entries containing MAC address to
             IP address bindings";
            container statics {
              description
                "Static Table Entries containing MAC address
               to IP address bindings";
              list static {
                key "mac-address client-id layer";
                description
                  "DHCP static binding of Mac address to IP
                 address";
                leaf mac-address {
                  type yang:mac-address;
                  description "MACAddress";
                }

                leaf client-id {
                  type Ipv4dhcpd-client-id;
                  description "Client Id";
                }

                leaf layer {
                  type Ipv4dhcpd-layer;
                  description
                    "DHCP IPV4 Static layer";
                }

                leaf static-address {
                  type inet:ipv4-address-no-zone;
                  mandatory true;
                  description "IP address";
                }
              }  // list static
            }  // container statics
          }  // container static-mode

          container cnbng-interface {
            description
              "DHCP IPv4 cnbng information";
            leaf profile {
              type string;
              description
                "Interface profile name";
            }
          }  // container cnbng-interface

          container profile {
            presence
              "Indicates a profile node is configured.";
            description
              "Profile name and mode";
            leaf profile-name {
              type string;
              mandatory true;
              description "Profile name";
            }

            leaf mode {
              type Ipv4dhcpd-mode;
              mandatory true;
              description "DHCP mode";
            }
          }  // container profile

          container server-interface {
            description
              "DHCP IPv4 Server information";
            container server-dhcp-circuit-id {
              presence
                "Indicates a server-dhcp-circuit-id node is configured.";
              description "Circuit ID value";
              leaf circuit-id {
                type string;
                mandatory true;
                description
                  "DHCP IPv4 circuit ID value";
              }

              leaf format {
                type Ipv4dhcpd-fmt;
                mandatory true;
                description "Format String";
              }

              leaf argument1 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument2 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument3 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument4 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument5 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument6 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument7 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument8 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument9 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument10 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument11 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument12 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument13 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument14 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument15 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }

              leaf argument16 {
                type Ipv4dhcpd-fmt-specifier;
                description "Argument";
              }
            }  // container server-dhcp-circuit-id

            leaf profile {
              type string;
              description
                "Interface profile name";
            }
          }  // container server-interface

          container snoop-interface {
            description
              "DHCP IPv4 snoop information";
            container snoop-circuit-id {
              description
                "Configure circuit ID for snoop 1. Hex 2.
               ASCII";
              leaf format-type {
                type uint32 {
                  range "1..2";
                }
                description
                  "Format type, 1. Hex 2. ASCII";
              }

              leaf circuit-id-value {
                type string;
                description
                  "Enter circuit-id value";
              }
            }  // container snoop-circuit-id
          }  // container snoop-interface

          leaf interface-name {
            type xr:Interface-name;
            description "Interface Name";
          }
        }  // list interface
      }  // container interfaces

      container duplicate-mac-allowed {
        presence
          "Indicates a duplicate-mac-allowed node is configured.";
        description
          "Allow Duplicate MAC Address";
        leaf duplicate-mac {
          type empty;
          mandatory true;
          description
            "Duplicate mac is allowed";
        }

        leaf exclude-vlan {
          type empty;
          description "Exclude vlan";
        }

        leaf include-giaddr {
          type empty;
          description "Include giaddr";
        }
      }  // container duplicate-mac-allowed

      container rate-limit {
        description
          "Rate limit ingress packets";
        leaf num-period {
          type uint32 {
            range "1..1000";
          }
          default "200";
          description
            "Rate limiter period in msec (default: 200 msec)";
        }

        leaf num-discover {
          type uint32 {
            range "0..1000";
          }
          default "100";
          description
            "Max DISCOVER packets per rate-limiter period
           (default 100)";
        }
      }  // container rate-limit

      leaf enable {
        type empty;
        mandatory true;
        description
          "DHCP IPV4 configuration";
      }

      leaf outer-cos {
        type uint32 {
          range "0..7";
        }
        description
          "Configure outer cos values for dhcp packets";
      }

      leaf allow-client-id-change {
        type empty;
        description
          "For BNG session, allow client id change for a
         client MAC";
      }

      leaf inner-cos {
        type uint32 {
          range "0..7";
        }
        description
          "Configure inner cos values for dhcp packets";
      }

      leaf disable-shadow-binding {
        type empty;
        description
          "Option to disable shadow binding";
      }
    }  // container ipv4-dhcpd
  }  // module Cisco-IOS-XR-ipv4-dhcpd-cfg