module huawei-bras-basic-access {

    yang-version 1;

    namespace
      "urn:huawei:yang:huawei-bras-basic-access";

    prefix bras-basic-access;

    import huawei-pub-type {
      prefix pub-type;
    }
    import huawei-extension {
      prefix ext;
    }
    import huawei-ifm {
      prefix ifm;
    }
    import huawei-aaa {
      prefix aaa;
    }
    import huawei-radius {
      prefix radius;
    }
    import huawei-devm {
      prefix devm;
    }
    import ietf-inet-types {
      prefix inet;
    }
    import huawei-time-range {
      prefix timerange;
    }
    import huawei-bras-ipv6-address-manage {
      prefix bras-ipv6-address-manage;
    }
    import huawei-bras-ipv4-address-manage {
      prefix bras-ipv4-address-manage;
    }
    import huawei-ethernet {
      prefix ethernet;
    }
    import huawei-ifm-trunk {
      prefix ifm-trunk;
    }

    organization
      "Huawei Technologies Co., Ltd.";

    contact
      "Huawei Industrial Base
Bantian, Longgang
Shenzhen 518129
People's Republic of China
Website: http://www.huawei.com
Email: support@huawei.com";

    description "Bras basic access.";

    revision "2020-03-12" {
      description "Modify description.";
      reference
        "Huawei private.";

    }

    revision "2019-03-26" {
      description "Init revision.";
      reference
        "Huawei private.";

    }

    ext:task-name "bras-control";

    typedef bras-basic-access-vendor-class-type {
      type enumeration {
        enum "option60" {
          value 1;
          description "Option60.";
        }
        enum "vendor-class" {
          value 2;
          description "Vendor class.";
        }
      }
      description
        "Description of vendor class type.";
    }

    typedef bras-basic-access-default-domain-type {
      type enumeration {
        enum "force" {
          value 1;
          description "Force.";
        }
        enum "replace" {
          value 2;
          description "Replace.";
        }
      }
      description
        "Indicates the default domain type.";
    }

    typedef bras-basic-access-annex-position-type {
      type enumeration {
        enum "right" {
          value 0;
          description
            "Adds string information to the right side.";
        }
        enum "left" {
          value 1;
          description
            "Adds string information to the left side.";
        }
      }
      description
        "Adds string information to the left or right side.";
    }

    typedef bras-basic-access-access-line-id-type {
      type enumeration {
        enum "option82" {
          value 1;
          description "Option82.";
        }
        enum "access-line-id" {
          value 2;
          description "Access line id.";
        }
      }
      description
        "Configures the router to trust the access-line-id information sent from the DHCP client.";
    }

    typedef bras-basic-access-trust-access-line-id-insert-version {
      type enumeration {
        enum "cn-telecom" {
          value 1;
          description
            "China telecom format.";
        }
        enum "client-version1" {
          value 2;
          description "Version1 format.";
        }
        enum "client-version3" {
          value 3;
          description "Version3 format.";
        }
        enum "cn-telecom-version2" {
          value 4;
          description
            "Cn-telecom version2 format.";
        }
      }
      description
        "Configures the router to trust the access-line-id information sent from the DHCP client.";
    }

    typedef bras-basic-access-distrust-access-line-id-insert-version {
      type enumeration {
        enum "cn-telecom" {
          value 1;
          description "Client-option82.";
        }
        enum "client-version2" {
          value 2;
          description "Client-version2.";
        }
      }
      description
        "Configures the router to trust the access-line-id information sent from the DHCP client.";
    }

    typedef bras-basic-access-nas-port-type {
      type enumeration {
        enum "async" {
          value 0;
          description "Async.";
        }
        enum "sync" {
          value 1;
          description "Sync.";
        }
        enum "isdn-sync" {
          value 2;
          description "Isdn-sync.";
        }
        enum "isdn-async-v120" {
          value 3;
          description "Isdn-async-v120.";
        }
        enum "isdn-async-v110" {
          value 4;
          description "Isdn-async-v110.";
        }
        enum "virtual" {
          value 5;
          description "Virtual.";
        }
        enum "piafs" {
          value 6;
          description "Piafs.";
        }
        enum "hdlc" {
          value 7;
          description "Hdlc.";
        }
        enum "x.25" {
          value 8;
          description "X.25.";
        }
        enum "x.75" {
          value 9;
          description "X.75.";
        }
        enum "g.3-fax" {
          value 10;
          description "G.3-fax.";
        }
        enum "sdsl" {
          value 11;
          description "Sdsl.";
        }
        enum "adsl-cap" {
          value 12;
          description "Adsl-cap.";
        }
        enum "adsl-dmt" {
          value 13;
          description "Adsl-dmt.";
        }
        enum "idsl" {
          value 14;
          description "Idsl.";
        }
        enum "ethernet" {
          value 15;
          description "Ethernet.";
        }
        enum "xdsl" {
          value 16;
          description "Xdsl.";
        }
        enum "cable" {
          value 17;
          description "Cable.";
        }
        enum "wireless-other" {
          value 18;
          description "Wireless other.";
        }
        enum "802.11" {
          value 19;
          description "802.11.";
        }
      }
      description
        "The type of the interface that accesses a BAS interface.";
    }

    typedef bras-basic-access-password-type {
      type enumeration {
        enum "simple" {
          value 4;
          description "Simple.";
        }
        enum "cipher" {
          value 5;
          description "Cipher.";
        }
      }
      description
        "Indicates the password Type.";
    }

    typedef bras-basic-access-access-limit-user-type {
      type enumeration {
        enum "none" {
          value 0;
          description "None.";
        }
        enum "ipoe" {
          value 1;
          description "Ipoe.";
        }
        enum "pppoe" {
          value 2;
          description "Pppoe.";
        }
        enum "ipv4" {
          value 3;
          description "IPv4.";
        }
        enum "ipv6" {
          value 4;
          description "IPv6.";
        }
      }
      description
        "Description of user type.";
    }

    typedef access-limit-user-type {
      type enumeration {
        enum "none" {
          value 0;
          description "None.";
        }
        enum "ipoe" {
          value 1;
          description "Ipoe.";
        }
        enum "pppoe" {
          value 2;
          description "Pppoe.";
        }
      }
      description
        "Specify the user-type to limit the maximum number of access users.";
    }

    typedef ip-pool-priority-layer2 {
      type enumeration {
        enum "local" {
          value 1;
          description
            "Indicates that a local IP address pool of Users takes precedence during address pool allocation.";
        }
        enum "remote" {
          value 2;
          description
            "Indicates that a remote IP address pool of Users takes precedence during address pool allocation.";
        }
      }
      description
        "The users priority in which an IP address pool assigns IP addresses.";
    }

    typedef ip-pool-priority-layer3 {
      type enumeration {
        enum "based-on-gateway-address" {
          value 0;
          description
            "Selects an IP address pool based on its gateway address.";
        }
        enum "local" {
          value 1;
          description
            "Indicates that a local IP address pool of Users takes precedence during address pool allocation.";
        }
        enum "remote" {
          value 2;
          description
            "Indicates that a remote IP address pool of Users takes precedence during address pool allocation.";
        }
      }
      description
        "The users priority in which an IP address pool assigns IP addresses.";
    }

    typedef bras-basic-access-identify-type {
      type enumeration {
        enum "auto" {
          value 0;
          description "Auto identify.";
        }
        enum "config" {
          value 1;
          description "Config identify.";
        }
      }
      description
        "Access line id identify type.";
    }

    typedef bras-basic-access-access-line-id-transmit-mode {
      type enumeration {
        enum "hex" {
          value 1;
          description
            "Configure suboption relay mode is hex to string.";
        }
        enum "string" {
          value 2;
          description
            "Configure suboption relay mode is string.";
        }
      }
      description
        "Access line id parse mode.";
    }

    container bras-basic-access {
      description "Bras basic access.";
      container user-groups {
        description
          "List of the user group.";
        list user-group {
          key "name";
          description
            "Configure a user group.";
          leaf name {
            type string {
              length "1..32";
              pattern '[!-~]{1,32}';
              pattern '[^"*?']{1,32}';
            }
            must
              "../name != '-' and ../name != '--' and ../name != 'a' and ../name != 'A' and ../name != 'an' and ../name != 'aN' and ../name != 'AN' and ../name != 'An' and ../name != 'Any' and ../name != 'AnY' and ../name != 'ANY' and ../name != 'ANy' and ../name != 'aNy' and ../name != 'aNY' and ../name != 'anY' and ../name != 'any'";
            description
              "Specifies the name of a user group. When the node of user-group-case-sensitive is enabled, the user group name is case-sensitive. When the node of user-group-case-sensitive is disabled, the user group name cannot contain uppercase letters.";
          }

          container traffic-policy-statistics {
            config false;
            description
              "List of the specified user group or all user groups.";
            list traffic-policy-statistic {
              key "policy-name up-group";
              description
                "Statistics of a specified user group or all user groups.";
              leaf policy-name {
                type string {
                  length "1..127";
                }
                description
                  "Name of a traffic policy.";
              }

              leaf up-group {
                type uint32 {
                  range "0..4294967295";
                }
                description
                  "ID of a up group.";
              }

              leaf user-group-type {
                type enumeration {
                  enum "local" {
                    value 1;
                    description
                      "The type of the user group is local.";
                  }
                  enum "remote" {
                    value 2;
                    description
                      "The type of the user group is remote.";
                  }
                  enum "dynamic" {
                    value 3;
                    description
                      "The type of the user group is dynamic.";
                  }
                  enum "combined" {
                    value 4;
                    description
                      "The type of the user group is combined.";
                  }
                }
                description
                  "Type of a user group.";
              }

              leaf is-mib-locked {
                type boolean;
                default "false";
                description
                  "Whether the MIB is locked.";
              }

              leaf is-nat-instance-valid {
                type boolean;
                default "false";
                description
                  "Whether an NAT instance is valid. By default, the value 0 indicates that an NAT instance is valid and the value 1 indicates that an NAT instance is invalid.";
              }

              leaf instance {
                type uint8;
                description
                  "Instance bound to a domain.";
              }

              leaf instance-type {
                type enumeration {
                  enum "nat" {
                    value 0;
                    description
                      "NAT instance bound to a domain.";
                  }
                  enum "ds-lite" {
                    value 1;
                    description
                      "DS-Lite instance bound to a domain.";
                  }
                }
                description
                  "Type of the instance bound to a domain.";
              }

              leaf bind-domain-number {
                type uint16;
                description
                  "Number of times that a user group is bound to a domain.";
              }

              leaf bind-daa-number {
                type uint32;
                description
                  "Number of times that a user group is bound to a DAA value-added-service policy template.";
              }

              leaf used-user-number {
                type uint32;
                description
                  "Number of users in a user group.";
              }

              leaf reference-cb-count {
                type uint16;
                description
                  "Number of times that combined user groups are bound to CB pairs in traffic policies.";
              }

              leaf is-wait-delete {
                type boolean;
                default "false";
                description
                  "WaitDelWhether the system waits for deleting a combined user group.";
              }

              leaf aging-time {
                type uint8;
                units "min";
                description
                  "Time after which the delete state of the combined user group will age.";
              }
            }  // list traffic-policy-statistic
          }  // container traffic-policy-statistics
        }  // list user-group
      }  // container user-groups

      container dhcp-multiple-sessions {
        must
          "not(./enable='true' and count(/bras-ipv6-address-manage:bras-ipv6-address-manage/bras-ipv6-address-manage:ipv6-prefixs/bras-ipv6-address-manage:ipv6-prefix/bras-ipv6-address-manage:delegation/bras-ipv6-address-manage:client-duid-binds/bras-ipv6-address-manage:client-duid-bind)>0)";
        must
          "not(./enable='true' and count(/bras-ipv4-address-manage:bras-ipv4-address-manage/bras-ipv4-address-manage:ipv4-pools/bras-ipv4-address-manage:ipv4-pool/bras-ipv4-address-manage:local/bras-ipv4-address-manage:sections/bras-ipv4-address-manage:section/bras-ipv4-address-manage:static-binds/bras-ipv4-address-manage:static-bind)>0)";
        description
          "Configure one-to-many mapping between one MAC address and many sessions.";
        leaf enable {
          type boolean;
          default "false";
          description
            "Enable/disable one-to-many mapping between one MAC address and many sessions, after one-to-many mapping between one MAC address and multiple sessions is enabled, the reserved type of an IPv6 prefix or address cannot be set to mac.";
        }
      }  // container dhcp-multiple-sessions

      container user-group-lists {
        description
          "List of the access user-group.";
        list user-group-list {
          key "name";
          max-elements 8;
          description
            "Configure the access user-group list.";
          leaf name {
            type string {
              length "1..32";
              pattern '[a-zA-Z0-9_]{1,32}';
            }
            description
              "Configures the name of an access user-group list.";
          }

          container user-groups {
            description
              "List of the user-group.";
            list user-group {
              key "name";
              max-elements 8;
              description
                "Configure the user groups of an access user-group list.";
              leaf name {
                type leafref {
                  path "/bras-basic-access:bras-basic-access/bras-basic-access:user-groups/bras-basic-access:user-group/bras-basic-access:name";
                }
                description
                  "Configures the name of a user-group.";
              }

              leaf weight {
                type uint8 {
                  range "1..100";
                }
                default "1";
                description
                  "Configures the weight of a user-group.";
              }
            }  // list user-group
          }  // container user-groups
        }  // list user-group-list
      }  // container user-group-lists

      container user-group-out-bound {
        description
          "Configure user group out bound.";
        leaf enable {
          type boolean;
          default "false";
          description
            "Enable/disable downstream packets to carry the source user's user-group ID in upstream packets.";
        }
      }  // container user-group-out-bound

      container user-group-case-sensitive {
        description
          "Configure user group case sensitive.";
        leaf enable {
          type boolean;
          default "false";
          description
            "Enable/disable the router to support case-sensitive user group names.";
        }
      }  // container user-group-case-sensitive

      container frame-ip-conflict-recycle {
        description
          "Configure the frame ip conflict recycle.";
        leaf enable {
          type boolean;
          default "false";
          description
            "Enable/disable the framed-ip conflict auto-recycle.";
        }
      }  // container frame-ip-conflict-recycle

      container access-delay-all {
        must "minimum <= maximum";
        presence
          "Enables the access response delay function globally.";
        description
          "Configure the access response delay function globally, and set the maximum and minimum access response delays on the specified board.";
        leaf step {
          type uint32 {
            range "1..262144";
          }
          mandatory true;
          description
            "Indicates the step of the number of access users. Each time the number of access users on the router increases by the number specified by step value, the response delay is prolonged. The response delay for the access users within the step range is the same.";
        }

        leaf minimum {
          type uint16 {
            range "0..2550";
          }
          mandatory true;
          description
            "Indicates the minimum response delay for access users on the minimum-time specifies the minimum response delay.";
        }

        leaf maximum {
          type uint16 {
            range "1..2550";
          }
          mandatory true;
          description
            "Indicates the maximum response delay for access users on the maximum-time specifies the maximum response delay.";
        }
      }  // container access-delay-all

      container access-delay-slots {
        description
          "List of the access response delay function globally, and set the maximum and minimum access response delays on the specified board.";
        list access-delay-slot {
          must "minimum <= maximum";
          key "slot";
          description
            "Configure the access response delay function globally, and set the maximum and minimum access response delays on the specified board.";
          leaf slot {
            type leafref {
              path "/devm:devm/devm:lpu-boards/devm:lpu-board/devm:position";
            }
            description
              "Indicates the access response delay function for access users on the specified board.";
          }

          leaf step {
            type uint32 {
              range "1..262144";
            }
            mandatory true;
            description
              "Indicates the step of the number of access users. Each time the number of access users on the router increases by the number specified by step value, the response delay is prolonged. The response delay for the access users within the step range is the same.";
          }

          leaf minimum {
            type uint16 {
              range "0..2550";
            }
            mandatory true;
            description
              "Indicates the minimum response delay for access users on the minimum-time specifies the minimum response delay.";
          }

          leaf maximum {
            type uint16 {
              range "1..2550";
            }
            mandatory true;
            description
              "Indicates the maximum response delay for access users on the maximum-time specifies the maximum response delay.";
          }
        }  // list access-delay-slot
      }  // container access-delay-slots

      container pppuser-offline-standardize {
        description
          "Configure a PPP user to preferentially get online when the PPP user and a DHCP user with the same MAC address attempt to get online.";
        leaf enable {
          type boolean;
          default "false";
          description
            "Enable/disable a PPP user to preferentially get online.";
        }
      }  // container pppuser-offline-standardize

      container nas-port-id-format {
        description
          "Configure nas port id format.";
        choice format {
          default "version20";
          description "Configure format.";
          case standard {
            description
              "Configure standard format.";
            leaf standard {
              type enumeration {
                enum "standard" {
                  value 0;
                  description
                    "Indicates the standard format conforming to the VBAS protocol.";
                }
                enum "standard-ignore" {
                  value 1;
                  description
                    "Indicates that the RID field in the Nas-Port-Id attribute carried by Option 82 is removed when indicates the standard format conforming to the VBAS protocol.";
                }
                enum "trust-outer-vlan" {
                  value 2;
                  description
                    "Indicates the standard format conforming to the VBAS protocol when trusts the outer VLAN tag value.";
                }
                enum
                  "trust-outer-vlan-ignore" {
                  value 3;
                  description
                    "Indicates that the RID field in the Nas-Port-Id attribute carried by Option 82 is removed when trusts the outer VLAN tag value.";
                }
                enum "trust-inner-vlan" {
                  value 4;
                  description
                    "Indicates the standard format conforming to the VBAS protocol when trusts the inner VLAN tag value.";
                }
                enum
                  "trust-inner-vlan-ignore" {
                  value 5;
                  description
                    "Indicates that the RID field in the Nas-Port-Id attribute carried by Option 82 is removed when trusts the inner VLAN tag value.";
                }
              }
              description
                "Configure the type of standard format.";
            }
          }  // case standard

          case turkey {
            description
              "Configure turkey format.";
            leaf turkey {
              type empty;
              description
                "Indicates the format of Turkey version.";
            }
          }  // case turkey

          case version10 {
            description
              "Configure version10 format.";
            leaf version10 {
              type empty;
              description
                "Indicates the format of version 1.0.";
            }
          }  // case version10

          case version20 {
            description
              "Configure version20 format.";
            leaf version20 {
              type empty;
              description
                "Indicates the format of version 2.0, by default, the format of version 2.0 is adopted.";
            }
          }  // case version20
        }  // choice format
      }  // container nas-port-id-format

      container packet-strict-check {
        description
          "Configure the router to strictly check user packets of a specific type.";
        leaf nd {
          type boolean;
          default "false";
          description
            "Enable/disable the strict ND packets check function.";
        }

        leaf dhcpv6 {
          type boolean;
          default "false";
          description
            "Enable/disable the strict DHCPv6 packets check function.";
        }

        leaf dhcp {
          type boolean;
          default "false";
          description
            "Enable/disable the strict DHCP packets check function.";
        }

        leaf ppp {
          type boolean;
          default "false";
          description
            "Enable/disable the strict PPP packets check function.";
        }

        leaf l2tp {
          type boolean;
          default "false";
          description
            "Enable/disable the strict L2TP packets check function.";
        }

        leaf dot1x {
          type boolean;
          default "false";
          description
            "Enable/disable the strict dot1x packets check function.";
        }
      }  // container packet-strict-check

      container protocol-statistics {
        description
          "Configure statistics about user protocol packets.";
        leaf enable {
          type boolean;
          default "false";
          description "Enable/disable flag.";
        }
      }  // container protocol-statistics

      container ui-mode {
        description
          "Configure the command output in the user-defined format.";
        leaf type {
          type enumeration {
            enum "type1" {
              value 1;
              description
                "User-defined Type 1 mode.";
            }
            enum "type2" {
              value 2;
              description
                "User-defined Type 2 mode.";
            }
          }
          description
            "Enable the user-defined format.";
        }
      }  // container ui-mode

      container user-flow-statistics {
        description
          "Configure user flow statistics.";
        leaf enable {
          type boolean;
          default "false";
          description
            "Enable/disable user flow statistics.";
        }
      }  // container user-flow-statistics

      container load-balance-enhance-algorithm {
        description
          "Configure the enhanced load balancing algorithm.";
        leaf enable {
          type boolean;
          default "false";
          description
            "Enable/disable the enhanced load balancing algorithm.";
        }

        leaf update-frequency {
          type uint32 {
            range "1..1000";
          }
          default "1";
          description
            "Specifies the frequency for triggering load balancing. It is the change of the number of users on an interface.";
        }
      }  // container load-balance-enhance-algorithm

      container load-balance-groups {
        description
          "List of load balancing groups.";
        list load-balance-group {
          key "name";
          max-elements 1024;
          description
            "Configure a load balanceing group.";
          leaf name {
            ext:case-sensitivity "lower-only";
            type string {
              length "1..31";
              pattern '[!-~]{1,31}';
              pattern '[^A-Z']{1,31}';
            }
            description
              "Specifies a name for a load balancing group.";
          }

          leaf delay-time {
            type uint32 {
              range "1..255";
            }
            units "10 ms";
            description
              "Specifies a delay time for a load balancing group.";
          }

          leaf member-count {
            type uint32 {
              range "0..16";
            }
            config false;
            description
              "Number of member interfaces in a load balancing group.";
          }

          leaf active-count {
            type uint32 {
              range "0..16";
            }
            config false;
            description
              "Number of active member interfaces in a load balancing group.";
          }

          container member-infos {
            config false;
            description
              "List of interface information of load balancing group.";
            list member-info {
              key "interface-name";
              description
                "Statistics of interface name of load balancing group member.";
              leaf interface-name {
                type string {
                  length "1..63";
                }
                description
                  "Name of a member interface.";
              }

              leaf number {
                type uint32;
                description
                  "Number of a member interface.";
              }

              leaf delay-time {
                type uint32;
                units "10 ms";
                description
                  "Delay time after which an interface responds to user login requests.";
              }

              leaf up-down-times {
                type uint32;
                description
                  "Number of times that a member interface alternates between up and down.";
              }

              leaf is-chasten {
                type boolean;
                description
                  "Penalty flag. A punished interface is not used for load balancing. The default penalty time is 5 minutes. After 5 minutes, the interface is available for load balancing again.";
              }

              leaf first-up-down-time {
                type string {
                  length "1..31";
                }
                description
                  "Time when an interface goes up or down for the first time if the penalty flag is not set, or penalty time if the penalty flag is set.";
              }
            }  // list member-info
          }  // container member-infos
        }  // list load-balance-group
      }  // container load-balance-groups
    }  // container bras-basic-access
  }  // module huawei-bras-basic-access