module dhcpv6-client {

    yang-version 1;

    namespace
      "urn:ietf:params:xml:ns:yang:dhcpv6-client";

    prefix dhcpv6;

    import ietf-inet-types {
      prefix inet;
      revision-date "2013-07-15";
    }
    import ietf-yang-types {
      prefix yang;
      revision-date "2013-07-15";
    }

    organization "dhc wg";

    contact
      "yong@csnet1.cs.tsinghua.edu.cn 
     wangh13@mails.tsinghua.edu.cn 
     lh.sunlinh@gmail.com 
     Ted.Lemon@nominum.com 
     ian.farrer@telekom.de";

    description
      "This model defines a YANG data model that can be 
     used to configure and manage DHCPv6 server, DHCPv6 relay and 
     DHCPv6 client.";

    revision "2015-10-16" {
      description
        "version05: Omit the feature statement. Modify 
       model according to comments from Huawei. Also correct some 
       grammar errors.";
      reference
        "I-D: draft-ietf-dhc-dhcpv6-yang-00";

    }

    revision "2015-09-25" {
      description
        "version04: Correct duid and grammar errors.";
      reference
        "I-D: draft-cui-dhc-dhcpv6-yang-04";

    }

    revision "2015-07-01" {
      description
        "version03: Correct grammar errors.";
      reference
        "I-D: draft-cui-dhc-dhcpv6-yang-03";

    }

    revision "2015-04-13" {
      description
        "version02: Correct grammar errors.";
      reference
        "I-D: draft-cui-dhc-dhcpv6-yang-02";

    }

    revision "2015-04-02" {
      description
        "version01: Correct grammar errors, Reuse 
       groupings, Update 'dhcpv6-relay' feature, Add 
       notifications.";
      reference
        "I-D: draft-cui-dhc-dhcpv6-yang-01";

    }

    revision "2015-03-04" {
      description
        "version00: Initial revision.";
      reference
        "I-D: draft-cui-dhc-dhcpv6-yang-00";

    }


    typedef duidtype {
      type union {
        type uint16;
        type string {
          pattern
            "(([0-9a-fA-F]{2}){2,128})";
        }
      }
      description
        "the type defined for duid";
    }

    typedef threshold {
      type union {
        type uint16 {
          range "0..100";
        }
        type enumeration {
          enum "disabled" {
            value 0;
            description "No threshold";
          }
        }
      }
      description
        "Threshold value in percent";
    }

    container serverv6 {
      description "dhcpv6 server portion";
      container serv-attributes {
        description
          "This container contains basic attributes 
         of a DHCPv6 server such as DUID, server name and so 
         on. Some optional functions that can be provided by 
         the server is also included.";
        leaf name {
          type string;
          mandatory true;
          description "server's name";
        }

        leaf duid {
          type duidtype;
          mandatory true;
          description
            "DHCP Unique Identifer";
        }

        leaf enable {
          type boolean;
          mandatory true;
          description
            "whether to enable the server";
        }

        leaf ipv6-address {
          type inet:ipv6-address;
          description
            "server's IPv6 address";
        }

        leaf description {
          type string;
          description
            "description of the server";
        }

        leaf pd-function {
          type boolean;
          mandatory true;
          description
            "Whether the server can act as a 
           delegating router to perform prefix delegation 
           ([RFC3633]).";
        }

        leaf stateless-service {
          type boolean;
          mandatory true;
          description
            "A boolean value specifies whether 
           the server support client-server exchanges 
           involving two messages defined in ([RFC3315]).";
        }

        leaf rapid-commit {
          type boolean;
          mandatory true;
          description
            "A boolean value specifies whether 
           the server support client-server exchanges 
           involving two messages defined in ([RFC3315]).";
        }

        leaf-list interfaces-config {
          type string;
          description
            "A leaf list to denote which one or 
           more interfaces the server should listen on. The 
           default value is to listen on all the interfaces. 
           This node is also used to set a unicast address 
           for the server to listen with a specific interface. 
           For example, if people want the server to listen 
           on a unicast address with a specific interface, he 
           can use the format like 'eth1/2001:db8::1'.";
        }

        container vendor-info {
          description "";
          leaf ent-num {
            type uint32;
            mandatory true;
            description "enterprise number";
          }

          leaf-list data {
            type string;
            description
              "specific vendor info";
          }
        }  // container vendor-info
      }  // container serv-attributes

      container option-sets {
        description
          "DHCPv6 employs various options to carry 
         additional information and parameters in DHCP messages. 
         This container defines all the possible options that 
         need to be configured at the server side.";
        list option-set {
          key "option-set-id";
          description
            "A server may allow different option 
           sets to be configured for different conditions 
           (i.e. different networks, clients and etc). This 
           'option-set' list enables various sets of options 
           being defined and configured in a single server. 
           Different sets are distinguished by the key called 
           'option-set-id'. All the possible options discussed 
           above are defined in the list and each option is 
           corresponding to a container.";
          leaf option-set-id {
            type uint8;
            mandatory true;
            description
              "the option-set-id key";
          }

          list new-or-standard-option {
            key "option-code";
            description
              "new or standard option";
            leaf option-code {
              type uint16;
              mandatory true;
              description
                "the option code key";
            }

            leaf option-name {
              type string;
              mandatory true;
              description
                "the new option's name";
            }

            leaf option-description {
              type string;
              mandatory true;
              description
                "description of new option";
            }

            leaf option-reference {
              type string;
              description
                "reference to the 
               specification";
            }

            leaf option-value {
              type string;
              mandatory true;
              description
                "the new option's value";
            }
          }  // list new-or-standard-option

          leaf user-class-value {
            type string;
            description
              "use class option's value";
          }

          leaf enterprise-number {
            type uint32;
            description "enterprise number";
          }

          leaf store-client-link-layer {
            type boolean;
            description
              "whether to store client's 
             link layer address";
          }

          container preference-option {
            description "preference option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            leaf preference-value {
              type uint8;
              mandatory true;
              description
                "the value for this option";
            }
          }  // container preference-option

          container sip-server-option {
            description "sip server option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list sip-server {
              key "sip-serv-id";
              description "sip server info";
              leaf sip-serv-id {
                type uint8;
                mandatory true;
                description "sip server id";
              }

              leaf sip-serv-domain-name {
                type string;
                mandatory true;
                description
                  "sip serevr domain 
                 name";
              }

              leaf sip-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "sip server addr";
              }
            }  // list sip-server
          }  // container sip-server-option

          container dns-config-option {
            description
              "dns configuration option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list dns-server {
              key "dns-serv-id";
              description "dns server info";
              leaf dns-serv-id {
                type uint8;
                mandatory true;
                description "dns server id";
              }

              leaf dns-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "dns server addr";
              }
            }  // list dns-server

            leaf domain-search-list {
              type string;
              mandatory true;
              description "search list";
            }
          }  // container dns-config-option

          container nis-config-option {
            description
              "nis configurtaion option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list nis-server {
              key "nis-serv-id";
              description "nis server info";
              leaf nis-serv-id {
                type uint8;
                mandatory true;
                description "nis server id";
              }

              leaf nis-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "nis server addr";
              }
            }  // list nis-server
          }  // container nis-config-option

          container nis-plus-config-option {
            description
              "nisp configuration option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list nis-plus-server {
              key "nis-plus-serv-id";
              description "nisp server info";
              leaf nis-plus-serv-id {
                type uint8;
                mandatory true;
                description "nisp server id";
              }

              leaf nis-plus-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "nisp server addr";
              }
            }  // list nis-plus-server
          }  // container nis-plus-config-option

          container info-refresh-time-option {
            description
              "info refresh time option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            leaf info-refresh-time {
              type yang:timeticks;
              mandatory true;
              description "the refresh time";
            }
          }  // container info-refresh-time-option

          container cli-fqdn-option {
            description "client fqdn option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            leaf server-initiate-update {
              type boolean;
              mandatory true;
              description "server initiate";
            }

            leaf client-initiate-update {
              type boolean;
              mandatory true;
              description "client initiate";
            }

            leaf modify-name-from-cli {
              type boolean;
              mandatory true;
              description "modify by client";
            }
          }  // container cli-fqdn-option

          container timezone-option {
            description "timezone option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            leaf tz-posix {
              type string;
              mandatory true;
              description "tz posix";
            }

            leaf tz-database {
              type string;
              mandatory true;
              description "tz database";
            }
          }  // container timezone-option

          container ntp-server-option {
            description "ntp server option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list ntp-server {
              key "ntp-serv-id";
              description "ntp server info";
              leaf ntp-serv-id {
                type uint8;
                mandatory true;
                description "ntp server id";
              }

              leaf ntp-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "ntp server addr";
              }

              leaf ntp-serv-mul-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "ntp server multicast 
                 addr";
              }

              leaf ntp-serv-fqdn {
                type string;
                mandatory true;
                description
                  "ntp server fqdn";
              }
            }  // list ntp-server
          }  // container ntp-server-option

          container sntp-server-option {
            description "sntp server option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list sntp-server {
              key "sntp-serv-id";
              description "sntp server info";
              leaf sntp-serv-id {
                type uint8;
                mandatory true;
                description "sntp server id";
              }

              leaf sntp-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "sntp server addr";
              }
            }  // list sntp-server
          }  // container sntp-server-option

          container network-boot-option {
            description
              "network boot option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list boot-file {
              key "boot-file-id";
              description "boot file info";
              leaf boot-file-id {
                type uint8;
                mandatory true;
                description "boot file id";
              }

              leaf-list suitable-arch-type {
                type uint16;
                description
                  "architecture type";
              }

              leaf-list suitable-net-if {
                type uint32;
                description
                  "network interface";
              }

              leaf boot-file-url {
                type string;
                mandatory true;
                description
                  "url for boot file";
              }

              list boot-file-paras {
                key "para-id";
                description
                  "boot file parameters";
                leaf para-id {
                  type uint8;
                  mandatory true;
                  description "parameter id";
                }

                leaf parameter {
                  type string;
                  mandatory true;
                  description
                    "parameter
                   value";
                }
              }  // list boot-file-paras
            }  // list boot-file
          }  // container network-boot-option

          container dslite-option {
            description "dslite option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            leaf dslite-aftr-name {
              type string;
              mandatory true;
              description "aftr name";
            }
          }  // container dslite-option

          container kerberos-option {
            description "kerberos option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            leaf default-realm-name {
              type string;
              mandatory true;
              description
                "default realm name";
            }

            list kdc-info {
              key "kdc-id";
              description "kdc info";
              leaf kdc-id {
                type uint8;
                mandatory true;
                description "kdc id";
              }

              leaf priority {
                type uint16;
                mandatory true;
                description "priority";
              }

              leaf weight {
                type uint16;
                mandatory true;
                description "weight";
              }

              leaf transport-type {
                type uint8;
                mandatory true;
                description "transport type";
              }

              leaf port-number {
                type uint16;
                mandatory true;
                description "port number";
              }

              leaf kdc-ipv6-addr {
                type inet:ipv6-address;
                mandatory true;
                description "kdc ipv6 addr";
              }

              leaf realm-name {
                type string;
                mandatory true;
                description "realm name";
              }
            }  // list kdc-info
          }  // container kerberos-option

          container addr-selection-option {
            description
              "address selection option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            leaf a-bit-set {
              type boolean;
              mandatory true;
              description "a bit";
            }

            leaf p-bit-set {
              type boolean;
              mandatory true;
              description "p bit";
            }

            list policy-table {
              key "policy-id";
              description "policy table";
              leaf policy-id {
                type uint8;
                mandatory true;
                description "policy id";
              }

              leaf label {
                type uint8;
                mandatory true;
                description "label";
              }

              leaf precedence {
                type uint8;
                mandatory true;
                description "precedence";
              }

              leaf prefix-len {
                type uint8;
                mandatory true;
                description "prefix length";
              }

              leaf prefix {
                type inet:ipv6-prefix;
                mandatory true;
                description "prefix";
              }
            }  // list policy-table
          }  // container addr-selection-option

          container sol-max-rt-option {
            description "sol max rt option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            leaf sol-max-rt-value {
              type yang:timeticks;
              mandatory true;
              description "sol max rt value";
            }
          }  // container sol-max-rt-option

          container inf-max-rt-option {
            description "inf max rt option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            leaf inf-max-rt-value {
              type yang:timeticks;
              mandatory true;
              description "inf max rt value";
            }
          }  // container inf-max-rt-option

          container pcp-server-option {
            description "pcp server option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list pcp-server {
              key "pcp-serv-id";
              description "pcp server info";
              leaf pcp-serv-id {
                type uint8;
                mandatory true;
                description "pcp server id";
              }

              leaf pcp-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "pcp server addr";
              }
            }  // list pcp-server
          }  // container pcp-server-option

          container s46-rule-option {
            description "s46 rule option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list s46-rule {
              key "rule-id";
              description "s46 rule";
              leaf rule-id {
                type uint8;
                mandatory true;
                description "rule id";
              }

              leaf rule-type {
                type enumeration {
                  enum "BMR" {
                    value 0;
                    description "BMR";
                  }
                  enum "FMR" {
                    value 1;
                    description "FMR";
                  }
                }
                mandatory true;
                description "rule type";
              }

              leaf prefix4-len {
                type uint8;
                mandatory true;
                description
                  "ipv4 prefix length";
              }

              leaf ipv4-prefix {
                type inet:ipv4-prefix;
                mandatory true;
                description "ipv4 prefix";
              }

              leaf prefix6-len {
                type uint8;
                mandatory true;
                description
                  "ipv6 prefix length";
              }

              leaf ipv6-prefix {
                type inet:ipv6-prefix;
                mandatory true;
                description "ipv6 prefix";
              }

              container port-parameter {
                description "port parameter";
                leaf offset {
                  type uint8;
                  mandatory true;
                  description
                    "offset in a port set";
                }

                leaf psid-len {
                  type uint8;
                  mandatory true;
                  description
                    "length of a psid";
                }

                leaf psid {
                  type uint16;
                  mandatory true;
                  description "psid value";
                }
              }  // container port-parameter
            }  // list s46-rule
          }  // container s46-rule-option

          container s46-br-option {
            description "s46 br option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list br {
              key "br-id";
              description "br info";
              leaf br-id {
                type uint8;
                mandatory true;
                description "br id";
              }

              leaf br-ipv6-addr {
                type inet:ipv6-address;
                mandatory true;
                description "br ipv6 addr";
              }
            }  // list br
          }  // container s46-br-option

          container s46-dmr-option {
            description "s46 dmr option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list dmr {
              key "dmr-id";
              description "dmr info";
              leaf dmr-id {
                type uint8;
                mandatory true;
                description "dmr id";
              }

              leaf dmr-prefix-len {
                type uint8;
                mandatory true;
                description
                  "dmr prefix length";
              }

              leaf dmr-ipv6-prefix {
                type inet:ipv6-prefix;
                mandatory true;
                description
                  "dmr ipv6 prefix";
              }
            }  // list dmr
          }  // container s46-dmr-option

          container s46-v4-v6-binding-option {
            description "s46 binding option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be included in the 
               option set";
            }

            list ce {
              key "ce-id";
              description "ce info";
              leaf ce-id {
                type uint8;
                mandatory true;
                description "ce id";
              }

              leaf ipv4-addr {
                type inet:ipv4-address;
                mandatory true;
                description "ce ipv4 addr";
              }

              leaf bind-prefix6-len {
                type uint8;
                mandatory true;
                description
                  "bind ipv6 prefix
                 length";
              }

              leaf bind-ipv6-prefix {
                type inet:ipv6-prefix;
                mandatory true;
                description
                  "bind ipv6 prefix";
              }

              container port-parameter {
                description "port parameter";
                leaf offset {
                  type uint8;
                  mandatory true;
                  description
                    "offset in a port set";
                }

                leaf psid-len {
                  type uint8;
                  mandatory true;
                  description
                    "length of a psid";
                }

                leaf psid {
                  type uint16;
                  mandatory true;
                  description "psid value";
                }
              }  // container port-parameter
            }  // list ce
          }  // container s46-v4-v6-binding-option
        }  // list option-set
      }  // container option-sets

      container network-ranges {
        description
          "This model supports a hierarchy 
         to achieve dynamic configuration. That is to 
         say we could configure the server at different 
         levels through this model. The top level is a 
         global level which is defined as the container 
         'network-ranges'. The following levels are 
         defined as sub-containers under it. The 
         'network-ranges' contains the parameters 
         (e.g. option-sets) that would be allocated to 
         all the clients served by this server.";
        leaf-list option-set {
          type uint8;
          description
            "a specific option set";
        }

        list network-range {
          key "network-range-id";
          description
            "Under the 'network-ranges' 
           container, a 'network-range' list is 
           defined to configure the server at a 
           network level which is also considered 
           as the second level. Different network 
           are identified by the key 'network-range-id'. 
           This is because a server may have different 
           configuration parameters (e.g. option sets) 
           for different networks.";
          leaf network-range-id {
            type uint8;
            mandatory true;
            description
              "equivalent to subnet id";
          }

          leaf network-description {
            type string;
            mandatory true;
            description
              "description of the subnet";
          }

          leaf network-prefix {
            type inet:ipv6-prefix;
            mandatory true;
            description "subnet prefix";
          }

          leaf inherit-option-set {
            type boolean;
            mandatory true;
            description
              "indicate whether to inherit 
             the configuration from higher level";
          }

          leaf-list option-set {
            type uint8;
            description
              "configured option set";
          }

          container address-pools {
            description
              "A container describes 
             the DHCPv6 server's address pools.";
            list address-pool {
              key "pool-id";
              description
                "A DHCPv6 server can 
               be configured with several address 
               pools. This list defines such 
               address pools which are distinguish 
               by the key called 'pool-name'.";
              leaf pool-id {
                type uint8;
                mandatory true;
                description "pool id";
              }

              leaf pool-prefix {
                type inet:ipv6-prefix;
                mandatory true;
                description "pool prefix";
              }

              leaf start-address {
                type inet:ipv6-address-no-zone;
                mandatory true;
                description "start address";
              }

              leaf end-address {
                type inet:ipv6-address-no-zone;
                mandatory true;
                description "end address";
              }

              leaf renew-time {
                type yang:timeticks;
                mandatory true;
                description "renew time";
              }

              leaf rebind-time {
                type yang:timeticks;
                mandatory true;
                description "rebind time";
              }

              leaf preferred-lifetime {
                type yang:timeticks;
                mandatory true;
                description
                  "preferred lifetime 
                 for IA";
              }

              leaf valid-lifetime {
                type yang:timeticks;
                mandatory true;
                description
                  "valid liftime for IA";
              }

              leaf total-ipv6-count {
                type uint64;
                config false;
                mandatory true;
                description
                  "how many ipv6 
                 addressses are in the pool";
              }

              leaf used-ipv6-count {
                type uint64;
                config false;
                mandatory true;
                description
                  "how many are 
                 allocated";
              }

              leaf utilization-ratio {
                type threshold;
                mandatory true;
                description
                  "the utilization ratio";
              }

              leaf inherit-option-set {
                type boolean;
                mandatory true;
                description
                  "indicate whether to 
                 inherit the configuration from 
                 higher level";
              }

              leaf-list option-set {
                type uint8;
                description
                  "configured option
                 set";
              }

              container reserved-addresses {
                description
                  "reserved addresses";
                list static-binding {
                  key "cli-id";
                  description
                    "static binding of 
                   reserved addresses";
                  leaf cli-id {
                    type uint32;
                    mandatory true;
                    description "client id";
                  }

                  leaf duid {
                    type duidtype;
                    mandatory true;
                    description
                      "DHCP Unique 
                     Identifer";
                  }

                  leaf-list reserv-addr {
                    type inet:ipv6-address;
                    description
                      "reserved addr";
                  }
                }  // list static-binding

                leaf-list other-reserv-addr {
                  type inet:ipv6-address;
                  description
                    "other reserved 
                   addr";
                }
              }  // container reserved-addresses
            }  // list address-pool

            list binding-info {
              key "cli-id";
              config false;
              description
                "A list records a binding 
               information for each DHCPv6 client 
               that has already been allocated IPv6 
               addresses.";
              leaf cli-id {
                type uint32;
                mandatory true;
                description "client id";
              }

              leaf duid {
                type duidtype;
                mandatory true;
                description
                  "DHCP Unique Identifer";
              }

              list cli-ia {
                key "iaid";
                description "client IA";
                leaf ia-type {
                  type string;
                  mandatory true;
                  description "IA type";
                }

                leaf iaid {
                  type uint32;
                  mandatory true;
                  description "IAID";
                }

                leaf-list cli-addr {
                  type inet:ipv6-address;
                  description "client addr";
                }

                leaf pool-id {
                  type uint8;
                  mandatory true;
                  description "pool id";
                }
              }  // list cli-ia
            }  // list binding-info
          }  // container address-pools

          container prefix-pools {
            description
              "If a server supports prefix 
             delegation function, this container will 
             be used to define the delegating router's 
             refix pools.";
            list prefix-pool {
              key "pool-id";
              description
                "Similar to server's 
               address pools, a delegating router 
               can also be configured with multiple 
               prefix pools specified by a list 
               called 'prefix-pool'.";
              leaf pool-id {
                type uint8;
                mandatory true;
                description "pool id";
              }

              leaf prefix {
                type inet:ipv6-prefix;
                mandatory true;
                description "ipv6 prefix";
              }

              leaf prefix-length {
                type uint8;
                mandatory true;
                description "prefix length";
              }

              leaf renew-time {
                type yang:timeticks;
                mandatory true;
                description "renew time";
              }

              leaf rebind-time {
                type yang:timeticks;
                mandatory true;
                description "rebind time";
              }

              leaf preferred-lifetime {
                type yang:timeticks;
                mandatory true;
                description
                  "preferred lifetime for 
                 IA";
              }

              leaf valid-lifetime {
                type yang:timeticks;
                mandatory true;
                description
                  "valid lifetime for IA";
              }

              leaf utilization-ratio {
                type threshold;
                mandatory true;
                description
                  "utilization ratio";
              }

              leaf inherit-option-set {
                type boolean;
                mandatory true;
                description
                  "whether to inherit 
                 configuration from higher level";
              }

              leaf-list option-set {
                type uint8;
                description
                  "configured option
                 set";
              }

              container reserved-prefixes {
                description
                  "reserved prefixes";
                list static-binding {
                  key "cli-id";
                  description
                    "static binding";
                  leaf cli-id {
                    type uint32;
                    mandatory true;
                    description "client id";
                  }

                  leaf duid {
                    type duidtype;
                    mandatory true;
                    description
                      "DHCP Unique 
                     Identifer";
                  }

                  leaf reserv-prefix-len {
                    type uint8;
                    mandatory true;
                    description
                      "reserved 
                     prefix length";
                  }

                  leaf reserv-prefix {
                    type inet:ipv6-prefix;
                    mandatory true;
                    description
                      "reserved prefix";
                  }
                }  // list static-binding

                leaf exclude-prefix-len {
                  type uint8;
                  mandatory true;
                  description
                    "exclude prefix 
                   length";
                }

                leaf exclude-prefix {
                  type inet:ipv6-prefix;
                  mandatory true;
                  description
                    "exclude prefix";
                }

                list other-reserv-prefix {
                  key "reserv-id";
                  description
                    "other reserved prefix";
                  leaf reserv-id {
                    type uint8;
                    mandatory true;
                    description
                      "reserved prefix id";
                  }

                  leaf prefix-len {
                    type uint8;
                    mandatory true;
                    description
                      "prefix length";
                  }

                  leaf prefix {
                    type inet:ipv6-prefix;
                    mandatory true;
                    description
                      "reserved prefix";
                  }
                }  // list other-reserv-prefix
              }  // container reserved-prefixes
            }  // list prefix-pool

            list binding-info {
              key "cli-id";
              config false;
              description
                "A list records a 
               binding information for each 
               DHCPv6 client that has already 
               been allocated IPv6 addresses.";
              leaf cli-id {
                type uint32;
                mandatory true;
                description "client id";
              }

              leaf duid {
                type duidtype;
                mandatory true;
                description
                  "DHCP Unique 
                 Identifier";
              }

              list cli-iapd {
                key "iaid";
                description "client IAPD";
                leaf iaid {
                  type uint32;
                  mandatory true;
                  description "IAID";
                }

                leaf-list cli-prefix {
                  type inet:ipv6-prefix;
                  description
                    "client ipv6 prefix";
                }

                leaf-list cli-prefix-len {
                  type uint8;
                  description
                    "client prefix length";
                }

                leaf pool-id {
                  type uint8;
                  mandatory true;
                  description "pool id";
                }
              }  // list cli-iapd
            }  // list binding-info
          }  // container prefix-pools

          container hosts {
            description "hosts level";
            list host {
              key "cli-id";
              description "specific host";
              leaf cli-id {
                type uint32;
                mandatory true;
                description "client id";
              }

              leaf duid {
                type duidtype;
                mandatory true;
                description
                  "DHCP Unique 
                 Identifer";
              }

              leaf inherit-option-set {
                type boolean;
                mandatory true;
                description
                  "whether to inherit 
                 configuration 
                 from higher level";
              }

              leaf-list option-set {
                type uint8;
                description
                  "configured option set";
              }

              leaf nis-domain-name {
                type string;
                description
                  "nis domain name";
              }

              leaf nis-plus-domain-name {
                type string;
                description
                  "nisp domain name";
              }
            }  // list host
          }  // container hosts
        }  // list network-range
      }  // container network-ranges

      container relay-opaque-paras {
        description
          "This container contains some 
         opaque values in Relay Agent options that 
         need to be configured on the server side 
         only for value match. Such Relay Agent 
         options include Interface-Id option, 
         Remote-Id option and Subscriber-Id option.";
        list relays {
          key "relay-name";
          description "relay agents";
          leaf relay-name {
            type string;
            mandatory true;
            description "relay agent name";
          }

          list interface-info {
            key "if-name";
            description "interface info";
            leaf if-name {
              type string;
              mandatory true;
              description "interface name";
            }

            leaf interface-id {
              type string;
              mandatory true;
              description "interface id";
            }
          }  // list interface-info

          list subscribers {
            key "subscriber";
            description "subscribers";
            leaf subscriber {
              type uint8;
              mandatory true;
              description "subscriber";
            }

            leaf subscriber-id {
              type string;
              mandatory true;
              description "subscriber id";
            }
          }  // list subscribers

          list remote-host {
            key "ent-num";
            description "remote host";
            leaf ent-num {
              type uint32;
              mandatory true;
              description
                "enterprise number";
            }

            leaf remote-id {
              type string;
              mandatory true;
              description "remote id";
            }
          }  // list remote-host
        }  // list relays
      }  // container relay-opaque-paras

      container rsoo-enabled-options {
        description "rsoo enabled options";
        list rsoo-enabled-option {
          key "option-code";
          description "rsoo enabled option";
          leaf option-code {
            type uint16;
            mandatory true;
            description "option code";
          }

          leaf description {
            type string;
            mandatory true;
            description
              "description of the option";
          }
        }  // list rsoo-enabled-option
      }  // container rsoo-enabled-options

      container packet-stats {
        config false;
        description
          "A container presents 
         the packet statistics related to 
         the DHCPv6 server.";
        leaf solicit-count {
          type uint32;
          mandatory true;
          description "solicit counter";
        }

        leaf request-count {
          type uint32;
          mandatory true;
          description "request counter";
        }

        leaf renew-count {
          type uint32;
          mandatory true;
          description "renew counter";
        }

        leaf rebind-count {
          type uint32;
          mandatory true;
          description "rebind counter";
        }

        leaf decline-count {
          type uint32;
          mandatory true;
          description "decline count";
        }

        leaf release-count {
          type uint32;
          mandatory true;
          description "release counter";
        }

        leaf info-req-count {
          type uint32;
          mandatory true;
          description
            "information request 
           counter";
        }

        leaf advertise-count {
          type uint32;
          mandatory true;
          description "advertise counter";
        }

        leaf confirm-count {
          type uint32;
          mandatory true;
          description "confirm counter";
        }

        leaf reply-count {
          type uint32;
          mandatory true;
          description "reply counter";
        }

        leaf reconfigure-count {
          type uint32;
          mandatory true;
          description "reconfigure counter";
        }

        leaf relay-forward-count {
          type uint32;
          mandatory true;
          description
            "relay forward counter";
        }

        leaf relay-reply-count {
          type uint32;
          mandatory true;
          description "relay reply counter";
        }
      }  // container packet-stats
    }  // container serverv6

    container relayv6 {
      description "dhcpv6 relay portion";
      container relay-attributes {
        description
          "A container describes 
         some basic attributes of the relay 
         agent including some relay agent 
         specific options data that need to 
         be configured previously. Such options 
         include Remote-Id option and 
         Subscriber-Id option.";
        leaf name {
          type string;
          mandatory true;
          description "relay agent name";
        }

        leaf enable {
          type boolean;
          mandatory true;
          description
            "whether the relay is enabled";
        }

        leaf description {
          type string;
          description
            "description of the relay agent";
        }

        leaf-list dest-addrs {
          type inet:ipv6-address;
          description
            "Each DHCPv6 relay agent may 
           be configured with a list of destination 
           addresses. This node defines such a list 
           of IPv6 addresses that may include 
           unicast addresses, multicast addresses 
           or other addresses.";
        }

        list subscribers {
          key "subscriber";
          description "subscribers";
          leaf subscriber {
            type uint8;
            mandatory true;
            description "subscriber";
          }

          leaf subscriber-id {
            type string;
            mandatory true;
            description "subscriber id";
          }
        }  // list subscribers

        list remote-host {
          key "ent-num";
          description "remote host";
          leaf ent-num {
            type uint32;
            mandatory true;
            description "enterprise number";
          }

          leaf remote-id {
            type string;
            mandatory true;
            description "remote id";
          }
        }  // list remote-host

        container vendor-info {
          description "";
          leaf ent-num {
            type uint32;
            mandatory true;
            description "enterprise number";
          }

          leaf-list data {
            type string;
            description
              "specific vendor info";
          }
        }  // container vendor-info
      }  // container relay-attributes

      container relay-supplied-options-option {
        description
          "relay supplied options option";
        list rsoo-set {
          key "rsoo-set-id";
          description "rsoo set";
          leaf rsoo-set-id {
            type uint8;
            mandatory true;
            description "rsoo set id";
          }

          container erp-local-domain-name-option {
            description
              "erp local domain name option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether 
               this option is included in the 
               rsoo set";
            }

            list erp-for-client {
              key "cli-id";
              description "erp for client";
              leaf cli-id {
                type uint32;
                mandatory true;
                description "client id";
              }

              leaf duid {
                type duidtype;
                mandatory true;
                description
                  "DHCP Unique 
                 Identifer";
              }

              leaf erp-name {
                type string;
                mandatory true;
                description "erp name";
              }
            }  // list erp-for-client
          }  // container erp-local-domain-name-option
        }  // list rsoo-set
      }  // container relay-supplied-options-option

      list relay-if {
        key "if-name";
        description
          "A relay agent may have several 
         interfaces, we should provide a way to configure 
         and manage parameters on the interface-level. A 
         list that describes specific interfaces and 
         their corresponding parameters is employed to 
         fulfil the configfuration. Here we use a string 
         called 'if-name; as the key of list.";
        leaf if-name {
          type string;
          mandatory true;
          description "interface name";
        }

        leaf enable {
          type boolean;
          mandatory true;
          description
            "whether this interface is enabled";
        }

        leaf ipv6-address {
          type inet:ipv6-address;
          description
            "ipv6 address for this interface";
        }

        leaf interface-id {
          type string;
          description "interface id";
        }

        leaf-list rsoo-set {
          type uint8;
          description "configured rsoo set";
        }

        list pd-route {
          key "pd-route-id";
          description "pd route";
          leaf pd-route-id {
            type uint8;
            mandatory true;
            description "pd route id";
          }

          leaf requesting-router-id {
            type uint32;
            mandatory true;
            description
              "requesting router id";
          }

          leaf delegating-router-id {
            type uint32;
            mandatory true;
            description
              "delegating router id";
          }

          leaf next-router {
            type inet:ipv6-address;
            mandatory true;
            description "next router";
          }

          leaf last-router {
            type inet:ipv6-address;
            mandatory true;
            description "previous router";
          }
        }  // list pd-route

        list next-entity {
          key "dest-addr";
          description
            "This node defines 
           a list that is used to describe 
           the next hop entity of this 
           relay distinguished by their 
           addresses.";
          leaf dest-addr {
            type inet:ipv6-address;
            mandatory true;
            description "destination addr";
          }

          leaf available {
            type boolean;
            mandatory true;
            description
              "whether the next entity 
             is available or not";
          }

          leaf multicast {
            type boolean;
            mandatory true;
            description
              "whether the address is 
             multicast or not";
          }

          leaf server {
            type boolean;
            mandatory true;
            description
              "whether the next entity 
             is a server";
          }

          container packet-stats {
            config false;
            description "packet statistics";
            leaf cli-packet-rvd-count {
              type uint32;
              mandatory true;
              description
                "client received packet 
               counter";
            }

            leaf solicit-rvd-count {
              type uint32;
              mandatory true;
              description
                "solicit received counter";
            }

            leaf request-rvd-count {
              type uint32;
              mandatory true;
              description
                "request received counter";
            }

            leaf renew-rvd-count {
              type uint32;
              mandatory true;
              description
                "renew received counter";
            }

            leaf rebind-rvd-count {
              type uint32;
              mandatory true;
              description
                "rebind recevied counter";
            }

            leaf decline-rvd-count {
              type uint32;
              mandatory true;
              description
                "decline received counter";
            }

            leaf release-rvd-count {
              type uint32;
              mandatory true;
              description
                "release received counter";
            }

            leaf info-req-rvd-count {
              type uint32;
              mandatory true;
              description
                "information request counter";
            }

            leaf relay-for-rvd-count {
              type uint32;
              mandatory true;
              description
                "relay forward received counter";
            }

            leaf relay-rep-rvd-count {
              type uint32;
              mandatory true;
              description
                "relay reply received counter";
            }

            leaf packet-to-cli-count {
              type uint32;
              mandatory true;
              description
                "packet to client counter";
            }

            leaf adver-sent-count {
              type uint32;
              mandatory true;
              description
                "advertisement sent counter";
            }

            leaf confirm-sent-count {
              type uint32;
              mandatory true;
              description
                "confirm sent counter";
            }

            leaf reply-sent-count {
              type uint32;
              mandatory true;
              description
                "reply sent counter";
            }

            leaf reconfig-sent-count {
              type uint32;
              mandatory true;
              description
                "reconfigure sent counter";
            }

            leaf relay-for-sent-count {
              type uint32;
              mandatory true;
              description
                "relay forward sent counter";
            }

            leaf relay-rep-sent-count {
              type uint32;
              mandatory true;
              description
                "relay reply sent counter";
            }
          }  // container packet-stats
        }  // list next-entity
      }  // list relay-if

      container relay-stats {
        config false;
        description "relay statistics";
        leaf cli-packet-rvd-count {
          type uint32;
          mandatory true;
          description
            "client packet received counter";
        }

        leaf relay-for-rvd-count {
          type uint32;
          mandatory true;
          description
            "relay forward received counter";
        }

        leaf relay-rep-rvd-count {
          type uint32;
          mandatory true;
          description
            "relay reply recevied counter";
        }

        leaf packet-to-cli-count {
          type uint32;
          mandatory true;
          description
            "packet to client counter";
        }

        leaf relay-for-sent-count {
          type uint32;
          mandatory true;
          description
            "relay forward sent counter";
        }

        leaf relay-rep-sent-count {
          type uint32;
          mandatory true;
          description
            "relay reply sent counter";
        }

        leaf discarded-packet-count {
          type uint32;
          mandatory true;
          description
            "discarded packet counter";
        }
      }  // container relay-stats
    }  // container relayv6

    container clientv6 {
      description "dhcpv6 client portion";
      list client-if {
        key "if-name";
        description
          "A client may have several 
         interfaces, it is more reasonable to 
         configure and manage parameters on 
         the interface-level. The list defines 
         specific client interfaces and their 
         data. Different interfaces are distinguished 
         by the key which is a configurable string 
         value.";
        leaf if-name {
          type string;
          mandatory true;
          description "interface name";
        }

        leaf cli-id {
          type uint32;
          mandatory true;
          description "client id";
        }

        leaf duid {
          type duidtype;
          mandatory true;
          description
            "DHCP Unique 
           Identifer";
        }

        leaf enable {
          type boolean;
          mandatory true;
          description
            "whether the interface is enabled";
        }

        leaf description {
          type string;
          description
            "description of the client interface";
        }

        leaf pd-function {
          type boolean;
          mandatory true;
          description
            "Whether the client 
           can act as a requesting router 
           to request prefixes using prefix 
           delegation ([RFC3633]).";
        }

        leaf rapid-commit {
          type boolean;
          mandatory true;
          description
            "'1' indicates a client can 
           initiate a Solicit-Reply message exchange 
           by adding a Rapid Commit option in Solicit 
           message. '0' means the client is not allowed 
           to add a Rapid Commit option to request 
           addresses in a two-message exchange 
           pattern.";
        }

        container mo-tab {
          description
            "The management tab 
           label indicates the operation 
           mode of the DHCPv6 client. 'm'=1 
           and 'o'=1 indicate the client 
           will use DHCPv6 to obtain all 
           the configuration data. 'm'=1 
           and 'o'=0 are a meaningless 
           combination. 'm'=0 and 'o'=1 
           indicate the client will use 
           stateless DHCPv6 to obtain 
           configuration data apart from 
           addresses/prefixes data. 
           'm'=0 and 'o'=0 represent the 
           client will not use DHCPv6 
           but use SLAAC to achieve 
           configuration.";
          leaf m-tab {
            type boolean;
            mandatory true;
            description "m tab";
          }

          leaf o-tab {
            type boolean;
            mandatory true;
            description "o tab";
          }
        }  // container mo-tab

        container oro-options {
          description "oro options";
          list oro-option {
            key "option-code";
            description "oro option";
            leaf option-code {
              type uint16;
              mandatory true;
              description "option code";
            }

            leaf description {
              type string;
              mandatory true;
              description
                "description of oro 
               options";
            }
          }  // list oro-option
        }  // container oro-options

        container client-configured-options {
          description
            "client configured options";
          list new-or-standard-cli-option {
            key "option-code";
            description
              "new or standard client option";
            leaf option-code {
              type uint16;
              mandatory true;
              description "option code";
            }

            leaf option-name {
              type string;
              mandatory true;
              description "option name";
            }

            leaf option-description {
              type string;
              mandatory true;
              description
                "description of client 
               option";
            }

            leaf option-reference {
              type string;
              description
                "the reference of option";
            }

            leaf option-value {
              type string;
              mandatory true;
              description "the option value";
            }
          }  // list new-or-standard-cli-option

          container user-class-option {
            description "user class option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be configured at the 
               client";
            }

            list user-class {
              key "user-class-id";
              description "user class";
              leaf user-class-id {
                type uint8;
                mandatory true;
                description "user class id";
              }

              leaf user-class-info {
                type string;
                mandatory true;
                description
                  "user class info";
              }
            }  // list user-class
          }  // container user-class-option

          container vendor-class-option {
            description
              "vendor class option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be configured at the 
               client";
            }

            leaf ent-num {
              type uint32;
              mandatory true;
              description
                "enterprise number";
            }

            leaf-list data {
              type string;
              description "option data";
            }
          }  // container vendor-class-option

          container client-fqdn-option {
            description "client fqdn option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be configured at the 
               client";
            }

            leaf fqdn {
              type string;
              mandatory true;
              description "fqdn";
            }

            leaf server-initiate-update {
              type boolean;
              mandatory true;
              description
                "whether server initiate";
            }

            leaf client-initiate-update {
              type boolean;
              mandatory true;
              description
                "whether client initiate";
            }
          }  // container client-fqdn-option

          container client-architecture-type-option {
            description
              "client architecture type option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be configured at the 
               client";
            }

            list architecture-types {
              key "type-id";
              description
                "architecture types";
              leaf type-id {
                type uint16;
                mandatory true;
                description "type id";
              }

              leaf most-preferred {
                type boolean;
                mandatory true;
                description
                  "most preferred flag";
              }
            }  // list architecture-types
          }  // container client-architecture-type-option

          container client-network-interface-option {
            description
              "client network interface option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be configured at the 
               client";
            }

            leaf type {
              type uint8;
              mandatory true;
              description "type";
            }

            leaf major {
              type uint8;
              mandatory true;
              description "major";
            }

            leaf minor {
              type uint8;
              mandatory true;
              description "minor";
            }
          }  // container client-network-interface-option

          container kerberos-principal-name-option {
            description
              "kerberos principal name option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be configured at the 
               client";
            }

            leaf principal-name {
              type string;
              mandatory true;
              description "principal name";
            }
          }  // container kerberos-principal-name-option

          container client-link-layer-addr-option {
            description
              "client link layer address option";
            leaf enable {
              type boolean;
              mandatory true;
              description
                "indicate whether this 
               option will be configured at the 
               client";
            }

            leaf link-layer-type {
              type uint16;
              mandatory true;
              description "link layer type";
            }

            leaf link-layer-addr {
              type string;
              mandatory true;
              description
                "link layer address";
            }
          }  // container client-link-layer-addr-option
        }  // container client-configured-options

        container identity-associations {
          config false;
          description
            "IA is a construct through 
           which a server and a client can identify, 
           group, and manage a set of related IPv6 
           addresses. The key of the list is a 
           4-byte number IAID defined in [RFC3315].";
          list identity-association {
            key "iaid";
            description "IA";
            leaf iaid {
              type uint32;
              mandatory true;
              description "IAID";
            }

            leaf ia-type {
              type string;
              mandatory true;
              description "IA type";
            }

            leaf-list ipv6-addr {
              type inet:ipv6-address;
              description "ipv6 address";
            }

            leaf-list ipv6-prefix {
              type inet:ipv6-prefix;
              description "ipv6 prefix";
            }

            leaf-list prefix-length {
              type uint8;
              description
                "ipv6 prefix length";
            }

            leaf t1-time {
              type yang:timeticks;
              mandatory true;
              description "t1 time";
            }

            leaf t2-time {
              type yang:timeticks;
              mandatory true;
              description "t2 time";
            }

            leaf preferred-lifetime {
              type yang:timeticks;
              mandatory true;
              description
                "preferred lifetime";
            }

            leaf valid-lifetime {
              type yang:timeticks;
              mandatory true;
              description "valid lifetime";
            }
          }  // list identity-association
        }  // container identity-associations

        container if-other-paras {
          config false;
          description
            "A client can obtain 
           extra configuration data other than 
           address and prefix information through 
           DHCPv6. This container describes such 
           data the client was configured. The 
           potential configuration data may 
           include DNS server addresses, SIP 
           server domain names, etc.";
          leaf-list uni-dhcpv6-serv-addr {
            type inet:ipv6-address;
            description
              "unicast server address";
          }

          container dns-paras {
            description "dns parameters";
            leaf domain-search-list {
              type string;
              mandatory true;
              description
                "domain search list";
            }

            list dns-servers {
              key "dns-serv-id";
              description "dns servers";
              leaf dns-serv-id {
                type uint8;
                mandatory true;
                description "dns server id";
              }

              leaf dns-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "dns server address";
              }
            }  // list dns-servers
          }  // container dns-paras

          container sip-paras {
            description "sip parameters";
            list sip-servers {
              key "sip-serv-id";
              description "sip server info";
              leaf sip-serv-id {
                type uint8;
                mandatory true;
                description "sip server id";
              }

              leaf sip-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "sip server address";
              }

              leaf sip-serv-domain-name {
                type string;
                mandatory true;
                description
                  "sip server domain name";
              }
            }  // list sip-servers
          }  // container sip-paras

          container nis-paras {
            description "nis parameters";
            leaf nis-domain-name {
              type string;
              mandatory true;
              description "nis domain name";
            }

            list nis-server {
              key "nis-serv-id";
              description "nis server";
              leaf nis-serv-id {
                type uint8;
                mandatory true;
                description "nis server id";
              }

              leaf nis-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "nis server address";
              }
            }  // list nis-server
          }  // container nis-paras

          container nis-plus-paras {
            description "nisp parameters";
            leaf nis-plus-domain-name {
              type string;
              mandatory true;
              description "nisp domian name";
            }

            list nis-plus-server {
              key "nis-plus-serv-id";
              description "nisp server";
              leaf nis-plus-serv-id {
                type uint8;
                mandatory true;
                description "nisp server id";
              }

              leaf nis-plus-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "nisp server address";
              }
            }  // list nis-plus-server
          }  // container nis-plus-paras

          leaf info-refresh-time {
            type yang:timeticks;
            description "info refresh time";
          }

          container time-zone-paras {
            description
              "time zone parameters";
            leaf tz-posix {
              type string;
              mandatory true;
              description "tz posix";
            }

            leaf tz-database {
              type string;
              mandatory true;
              description "tz database";
            }
          }  // container time-zone-paras

          leaf cli-fqdn {
            type string;
            description "client fqdn";
          }

          container ntp-paras {
            description "ntp parameters";
            list ntp-server {
              key "ntp-serv-id";
              description "ntp server";
              leaf ntp-serv-id {
                type uint8;
                mandatory true;
                description "ntp server id";
              }

              leaf ntp-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "ntp server address";
              }

              leaf ntp-serv-mul-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "ntp server multicast 
                 address";
              }

              leaf ntp-serv-fqdn {
                type string;
                mandatory true;
                description
                  "ntp server fqdn";
              }
            }  // list ntp-server
          }  // container ntp-paras

          container sntp-paras {
            description "sntp parameters";
            list sntp-server {
              key "sntp-serv-id";
              description "sntp server";
              leaf sntp-serv-id {
                type uint8;
                mandatory true;
                description "sntp server id";
              }

              leaf sntp-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "sntp server address";
              }
            }  // list sntp-server
          }  // container sntp-paras

          container network-boot-paras {
            description
              "network boot parameters";
            list boot-file {
              key "boot-file-id";
              description "boot file";
              leaf boot-file-id {
                type uint8;
                mandatory true;
                description "boot file id";
              }

              leaf-list suitable-arch-type {
                type uint16;
                description
                  "architecture type";
              }

              leaf-list suitable-net-if {
                type uint32;
                description
                  "network interface";
              }

              leaf boot-file-url {
                type string;
                mandatory true;
                description "boot file url";
              }

              list boot-file-paras {
                key "para-id";
                description
                  "boot file parameters";
                leaf para-id {
                  type uint8;
                  mandatory true;
                  description "parameter id";
                }

                leaf parameter {
                  type string;
                  mandatory true;
                  description
                    "parameter value";
                }
              }  // list boot-file-paras
            }  // list boot-file
          }  // container network-boot-paras

          container kerberos-paras {
            description
              "kerberos parameters";
            leaf default-realm-name {
              type string;
              mandatory true;
              description
                "default realm name";
            }

            list kdc-info {
              key "kdc-id";
              description "kdc info";
              leaf kdc-id {
                type uint8;
                mandatory true;
                description "kdc id";
              }

              leaf priority {
                type uint16;
                mandatory true;
                description "priority";
              }

              leaf weight {
                type uint16;
                mandatory true;
                description "weight";
              }

              leaf transport-type {
                type uint8;
                mandatory true;
                description "transport type";
              }

              leaf port-number {
                type uint16;
                mandatory true;
                description "port number";
              }

              leaf kdc-ipv6-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "kdc ipv6 address";
              }

              leaf realm-name {
                type string;
                mandatory true;
                description "realm name";
              }
            }  // list kdc-info
          }  // container kerberos-paras

          container addr-selection-paras {
            description
              "address selection parameters";
            leaf automatic-row-add {
              type boolean;
              mandatory true;
              description "row add";
            }

            leaf prefer-temporary-addr {
              type boolean;
              mandatory true;
              description "prefer temporary";
            }

            list policy-table {
              key "policy-id";
              description "policy table";
              leaf policy-id {
                type uint8;
                mandatory true;
                description "policy id ";
              }

              leaf label {
                type uint8;
                mandatory true;
                description "label";
              }

              leaf precedence {
                type uint8;
                mandatory true;
                description "precedence";
              }

              leaf prefix-len {
                type uint8;
                mandatory true;
                description "prefix length";
              }

              leaf prefix {
                type inet:ipv6-prefix;
                mandatory true;
                description "prefix";
              }
            }  // list policy-table
          }  // container addr-selection-paras

          leaf sol-max-rt {
            type yang:timeticks;
            mandatory true;
            description "sol max rt";
          }

          leaf inf-max-rt {
            type yang:timeticks;
            mandatory true;
            description "inf max rt";
          }

          container pcp-server-paras {
            description
              "pcp server parameters";
            list pcp-server {
              key "pcp-serv-id";
              description "pcp server";
              leaf pcp-serv-id {
                type uint8;
                mandatory true;
                description "pcp server id";
              }

              leaf pcp-serv-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "pcp server address";
              }
            }  // list pcp-server
          }  // container pcp-server-paras

          container s46-rule-paras {
            description
              "s46 rule parameters";
            list s46-rule {
              key "rule-id";
              description "s46 rule";
              leaf rule-id {
                type uint8;
                mandatory true;
                description "rule id";
              }

              leaf rule-type {
                type enumeration {
                  enum "BMR" {
                    value 0;
                    description "BMR";
                  }
                  enum "FMR" {
                    value 1;
                    description "FMR";
                  }
                }
                mandatory true;
                description "rule type";
              }

              leaf ea-len {
                type uint8;
                mandatory true;
                description "EA bits length";
              }

              leaf prefix4-len {
                type uint8;
                mandatory true;
                description
                  "ipv4 prefix length";
              }

              leaf ipv4-prefix {
                type inet:ipv4-prefix;
                mandatory true;
                description "ipv4 prefix";
              }

              leaf prefix6-len {
                type uint8;
                mandatory true;
                description
                  "ipv6 prefix length";
              }

              leaf ipv6-prefix {
                type inet:ipv6-prefix;
                mandatory true;
                description "ipv6 prefix";
              }

              container port-parameter {
                description "port parameter";
                leaf offset {
                  type uint8;
                  mandatory true;
                  description
                    "offset in a port set";
                }

                leaf psid-len {
                  type uint8;
                  mandatory true;
                  description
                    "length of a psid";
                }

                leaf psid {
                  type uint16;
                  mandatory true;
                  description "psid value";
                }
              }  // container port-parameter
            }  // list s46-rule
          }  // container s46-rule-paras

          container s46-br-paras {
            description "s46 br parameters";
            list br {
              key "br-id";
              description "br";
              leaf br-id {
                type uint8;
                mandatory true;
                description "br id";
              }

              leaf br-ipv6-addr {
                type inet:ipv6-address;
                mandatory true;
                description
                  "br ipv6 address";
              }
            }  // list br
          }  // container s46-br-paras

          container s46-dmr-paras {
            description "s46 dmr parameters";
            list dmr {
              key "dmr-id";
              description "dmr";
              leaf dmr-id {
                type uint8;
                mandatory true;
                description "dmr id";
              }

              leaf dmr-prefix-len {
                type uint8;
                mandatory true;
                description
                  "dmr prefix length";
              }

              leaf dmr-ipv6-prefix {
                type inet:ipv6-prefix;
                mandatory true;
                description "dmr prefix";
              }
            }  // list dmr
          }  // container s46-dmr-paras

          container s46-v4-v6-binding-paras {
            description
              "s46 v4 v6 binding parameters";
            leaf ipv4-addr {
              type inet:ipv4-address;
              mandatory true;
              description "ipv4 address";
            }

            leaf bind-prefix6-len {
              type uint8;
              mandatory true;
              description "bind ipv6 prefix";
            }

            container port-parameter {
              description "port parameter";
              leaf offset {
                type uint8;
                mandatory true;
                description
                  "offset in a port set";
              }

              leaf psid-len {
                type uint8;
                mandatory true;
                description
                  "length of a psid";
              }

              leaf psid {
                type uint16;
                mandatory true;
                description "psid value";
              }
            }  // container port-parameter

            leaf erp-local-domain-name {
              type string;
              mandatory true;
              description
                "erp local domain name";
            }
          }  // container s46-v4-v6-binding-paras

          container supported-options {
            description "supported options";
            list supported-option {
              key "option-code";
              description "supported option";
              leaf option-code {
                type uint16;
                mandatory true;
                description "option code";
              }

              leaf description {
                type string;
                mandatory true;
                description
                  "description of supported 
                 option";
              }
            }  // list supported-option
          }  // container supported-options
        }  // container if-other-paras

        container packet-stats {
          config false;
          description
            "A container records 
           all the packet status information 
           of a specific interface.";
          leaf solicit-count {
            type uint32;
            mandatory true;
            description "solicit counter";
          }

          leaf request-count {
            type uint32;
            mandatory true;
            description "request counter";
          }

          leaf renew-count {
            type uint32;
            mandatory true;
            description "renew counter";
          }

          leaf rebind-count {
            type uint32;
            mandatory true;
            description "rebind counter";
          }

          leaf decline-count {
            type uint32;
            mandatory true;
            description "decline counter";
          }

          leaf release-count {
            type uint32;
            mandatory true;
            description "release counter";
          }

          leaf info-req-count {
            type uint32;
            mandatory true;
            description
              "information request counter";
          }

          leaf advertise-count {
            type uint32;
            mandatory true;
            description "advertise counter";
          }

          leaf confirm-count {
            type uint32;
            mandatory true;
            description "confirm counter";
          }

          leaf reply-count {
            type uint32;
            mandatory true;
            description "reply counter";
          }

          leaf reconfigure-count {
            type uint32;
            mandatory true;
            description "recofigure counter";
          }
        }  // container packet-stats
      }  // list client-if
    }  // container clientv6

    notification notifications {
      description
        "dhcpv6 notification module";
      container dhcpv6-server-event {
        description "dhcpv6 server event";
        container pool-running-out {
          description
            "raised when the 
           address/prefix pool is going to
           run out.  A threshold for utilization 
           ratio of the pool has been defined in 
           the server feature so that it will 
           notify the administrator when the 
           utilization ratio reaches the threshold,
           and such threshold is a settable 
           parameter";
          leaf utilization-ratio {
            type uint16;
            mandatory true;
            description "utilization ratio";
          }

          leaf duid {
            type duidtype;
            mandatory true;
            description
              "DHCP Unique 
             Identifer";
          }

          leaf serv-name {
            type string;
            description "server name";
          }

          leaf pool-name {
            type string;
            mandatory true;
            description "pool name";
          }
        }  // container pool-running-out

        container invalid-client-detected {
          description
            "raised when the server 
           has found a client which can be 
           regarded as a potential attacker. Some 
           description could also be included.";
          leaf duid {
            type duidtype;
            mandatory true;
            description
              "DHCP Unique 
             Identifer";
          }

          leaf description {
            type string;
            description
              "description of the event";
          }
        }  // container invalid-client-detected
      }  // container dhcpv6-server-event

      container dhcpv6-relay-event {
        description "dhcpv6 relay event";
        container topo-changed {
          description
            "raised when the topology 
           of the relay agent is changed.";
          leaf relay-if-name {
            type string;
            mandatory true;
            description
              "relay interface name";
          }

          leaf first-hop {
            type boolean;
            mandatory true;
            description "first hop";
          }

          leaf last-entity-addr {
            type inet:ipv6-address;
            mandatory true;
            description
              "last entity address";
          }
        }  // container topo-changed
      }  // container dhcpv6-relay-event

      container dhcpv6-client-event {
        description "dhcpv6 client event";
        container ia-lease-event {
          description
            "raised when the 
           client was allocated a new IA from 
           the server or it renew/rebind/release 
           its current IA";
          leaf event-type {
            type enumeration {
              enum "allocation" {
                value 0;
                description "allocate";
              }
              enum "rebind" {
                value 1;
                description "rebind";
              }
              enum "renew" {
                value 2;
                description "renew";
              }
              enum "release" {
                value 3;
                description "release";
              }
            }
            mandatory true;
            description "event type";
          }

          leaf duid {
            type duidtype;
            mandatory true;
            description
              "DHCP Unique 
             Identifer";
          }

          leaf iaid {
            type uint32;
            mandatory true;
            description "IAID";
          }

          leaf serv-name {
            type string;
            description "server name";
          }

          leaf description {
            type string;
            description
              "description of event";
          }
        }  // container ia-lease-event

        container invalid-ia-detected {
          description
            "raised when the identity 
           association of the client can be proved 
           to be invalid.  Possible condition includes 
           duplicated address, illegal address, etc.";
          leaf duid {
            type duidtype;
            mandatory true;
            description
              "DHCP Unique 
             Identifer";
          }

          leaf cli-duid {
            type uint32;
            mandatory true;
            description "duid of client";
          }

          leaf iaid {
            type uint32;
            mandatory true;
            description "IAID";
          }

          leaf serv-name {
            type string;
            description "server name";
          }

          leaf description {
            type string;
            description
              "description of the event";
          }
        }  // container invalid-ia-detected

        container retransmission-failed {
          description
            "raised when the retransmission 
           mechanism defined in [RFC3315] is failed.";
          leaf duid {
            type duidtype;
            description "DUID";
          }

          leaf description {
            type enumeration {
              enum "MRC failed" {
                value 0;
                description "MRC failed";
              }
              enum "MRD failed" {
                value 1;
                description "MRD failed";
              }
            }
            mandatory true;
            description
              "description of failure";
          }
        }  // container retransmission-failed

        container failed-status-turn-up {
          description
            "raised when the client receives 
           a message includes an unsuccessful Status Code 
           option.";
          leaf duid {
            type duidtype;
            mandatory true;
            description
              "DHCP Unique 
             Identifer";
          }

          leaf status-code {
            type enumeration {
              enum "1" {
                value 0;
                description "UnspecFail";
              }
              enum "2" {
                value 1;
                description "NoAddrAvail";
              }
              enum "3" {
                value 2;
                description "NoBinding";
              }
              enum "4" {
                value 3;
                description "NotOnLink";
              }
              enum "5" {
                value 4;
                description "UseMulticast";
              }
            }
            mandatory true;
            description
              "employed status code";
          }
        }  // container failed-status-turn-up
      }  // container dhcpv6-client-event
    }  // notification notifications
  }  // module dhcpv6-client