module Cisco-IOS-XR-um-if-bundle-cfg {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-um-if-bundle-cfg";

    prefix um-if-bundle-cfg;

    import cisco-semver {
      prefix semver;
    }
    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import Cisco-IOS-XR-um-interface-cfg {
      prefix a1;
    }
    import tailf-common {
      prefix tailf;
    }

    organization "Cisco Systems, Inc.";

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

    description
      "This module contains a collection of YANG definitions
     for Cisco IOS-XR if-bundle package configuration.
     
     This YANG module augments the
     modules with configuration data.
     
     Copyright (c) 2019-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-12-21" {
      description
        "Added logging container inside bundle
       2020-12-15
         Changed type of mlacp/switchover/maximize/bandwidth/threshold
       from uint32 to uint64";
    }

    revision "2020-05-26" {
      description
        "- Updated integer range of mbps and gbps
       - Removed container period-on-bundle and when statement from
       container period
       - Added when statement as appropriate
       2020-05-15
       Leaf changes for ipv4 container
       2020-04-27
       model leaf changes for ipv4 and ipv6 containers";
    }

    revision "2019-06-10" {
      description
        "Establish semantic version baseline.";
    }

    revision "2019-03-29" {
      description "Initial version";
    }

    semver:module-version "2.1.0";
    semver:module-version "2.0.0";
    semver:module-version "1.0.1";

    grouping GROUP-BUNDLE {
      container bundle {
        tailf:dependency "../a1:interface-name";
        when
          "../a1:interface-name[starts-with(text(),'GigabitEthernet')] or ../a1:interface-name[starts-with(text(),'TenGigE')] or ../a1:interface-name[starts-with(text(),'FortyGigE')] or ../a1:interface-name[starts-with(text(),'HundredGigE')] or ../a1:interface-name[starts-with(text(),'TwoHundredGigE')] or ../a1:interface-name[starts-with(text(),'FourHundredGigE')] or ../a1:interface-name[starts-with(text(),'TwentyFiveGigE')] or ../a1:interface-name[starts-with(text(),'FiftyGigE')] or ../a1:interface-name[starts-with(text(),'Bundle-')]";
        description
          "Bundle interface commands";
        container minimum-active {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          description
            "Set the minimum criteria for the bundle to be active";
          leaf links {
            type uint32 {
              range "1..64";
            }
            description
              "Set the number of active links needed to bring up this bundle";
          }

          container bandwidth {
            description
              "Set the bandwidth needed to bring up this bundle";
            leaf bandwidth {
              type uint32 {
                range "1..4294967295";
              }
              description
                "Set the bandwidth (in kbps) needed to bring up this bundle";
            }

            leaf kbps {
              type uint32 {
                range "1..4294967295";
              }
              description
                "Set the bandwidth in kbps";
            }

            leaf mbps {
              type uint32 {
                range "1..4294967295";
              }
              description
                "Set the bandwidth in mbps";
            }

            leaf gbps {
              type uint32 {
                range "1..4294967295";
              }
              description
                "Set the bandwidth in gbps";
            }
          }  // container bandwidth
        }  // container minimum-active

        container maximum-active {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          description
            "Set a limit on the number of links that can be active";
          container links {
            presence
              "Indicates a links node is configured.";
            description
              "Set the maximum number of active links in this bundle";
            leaf maximum-number {
              type uint32 {
                range "1..64";
              }
              mandatory true;
              description
                "Set the maximum number of active links in this bundle";
            }

            container hot-standby {
              presence
                "Indicates a hot-standby node is configured.";
              description
                "Hot-standby behaviour (non-standard, only effective on links with LACP enabled)";
            }  // container hot-standby
          }  // container links
        }  // container maximum-active

        leaf wait-while {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          type uint32 {
            range "0..2000";
          }
          description
            "Set the wait-while timeout for members of this bundle";
        }

        container shutdown {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          presence
            "Indicates a shutdown node is configured.";
          description
            "Bring all links in the bundle down to Standby state";
        }  // container shutdown

        container load-balancing {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          description
            "Load balancing commands on a bundle";
          container hash {
            description
              "Select the hash function used for traffic forwarded over the bundle";
            container src-ip {
              presence
                "Indicates a src-ip node is configured.";
              description
                "Use the source IP as the hash function";
            }  // container src-ip

            container dst-ip {
              presence
                "Indicates a dst-ip node is configured.";
              description
                "Use the destination IP as the hash function";
            }  // container dst-ip
          }  // container hash

          container localize {
            description
              "Restrict forwarding to members in the same rack where possible";
            container threshold {
              description
                "The threshold below which traffic is no longer localized";
              leaf links {
                type uint32 {
                  range "1..64";
                }
                description
                  "Set a threshold of active member links per rack";
              }
            }  // container threshold
          }  // container localize
        }  // container load-balancing

        leaf lacp-delay {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          type uint32 {
            range "1000..15000";
          }
          description
            "Set the lacp-delay timeout for members of this bundle";
        }

        container logging {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          description
            "logging events for the members of this bundle";
          container oos {
            presence
              "Indicates a oos node is configured.";
            description
              "Enable OOS logging events for the members of this bundle";
          }  // container oos
        }  // container logging

        container lacp-fallback {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          description
            "Set the lacp-fallback for members of this bundle";
          leaf timeout {
            type uint32 {
              range "1..120";
            }
            description
              "Set the timeout for lacp-fallback";
          }
        }  // container lacp-fallback

        container id {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'GigabitEthernet')] or ../../a1:interface-name[starts-with(text(),'TenGigE')] or ../../a1:interface-name[starts-with(text(),'FortyGigE')] or ../../a1:interface-name[starts-with(text(),'HundredGigE')] or ../../a1:interface-name[starts-with(text(),'TwoHundredGigE')] or ../../a1:interface-name[starts-with(text(),'FourHundredGigE')] or ../../a1:interface-name[starts-with(text(),'TwentyFiveGigE')] or ../../a1:interface-name[starts-with(text(),'FiftyGigE')]";
          presence
            "Indicates a id node is configured.";
          description
            "Add the port to an aggregated interface.";
          leaf bundle-id {
            type uint32 {
              range "1..65535";
            }
            mandatory true;
            description
              "Add the port to an aggregated interface.";
          }

          leaf mode {
            type enumeration {
              enum "on" {
                value 1;
                description
                  "Do not run LACP over the port.";
              }
              enum "active" {
                value 2;
                description
                  "Run LACP in active mode over the port.";
              }
              enum "passive" {
                value 3;
                description
                  "Run LACP in passive mode over the port.";
              }
              enum "inherit" {
                value 4;
                description
                  "Run LACP as configured in bundle.";
              }
            }
            mandatory true;
            description
              "Specify the mode of operation.";
          }
        }  // container id

        leaf port-priority {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'GigabitEthernet')] or ../../a1:interface-name[starts-with(text(),'TenGigE')] or ../../a1:interface-name[starts-with(text(),'FortyGigE')] or ../../a1:interface-name[starts-with(text(),'HundredGigE')] or ../../a1:interface-name[starts-with(text(),'TwoHundredGigE')] or ../../a1:interface-name[starts-with(text(),'FourHundredGigE')] or ../../a1:interface-name[starts-with(text(),'TwentyFiveGigE')] or ../../a1:interface-name[starts-with(text(),'FiftyGigE')]";
          type uint32 {
            range "1..65535";
          }
          description
            "Priority for this port. Lower value is higher priority.";
        }
      }  // container bundle

      container bfd {
        tailf:dependency "../a1:interface-name";
        when
          "../a1:interface-name[starts-with(text(),'Bundle-')]";
        description
          "BFD configuration on a bundle interface";
        container address-family {
          description
            "Set configuration for a given address family";
          container ipv4 {
            description
              "Set configuration for the IPv4 address family";
            leaf destination {
              type inet:ipv4-address-no-zone;
              description
                "Set the destination address for the BFD session";
            }

            container echo {
              description
                "Set the configuration for the echo mode of BFD";
              leaf minimum-interval {
                type uint32 {
                  range "15..2000";
                }
                description
                  "Set the preferred minimum interval for the BFD session";
              }
            }  // container echo

            leaf minimum-interval {
              type uint32 {
                range "3..30000";
              }
              description
                "Set the preferred minimum interval for the BFD session";
            }

            leaf multiplier {
              type uint32 {
                range "2..50";
              }
              description
                "Set the preferred multiplier for the BFD session";
            }

            container fast-detect {
              presence
                "Indicates a fast-detect node is configured.";
              description
                "Enable fast detection using BFD on bundle members";
            }  // container fast-detect

            container timers {
              description
                "Set the timers that determine when a BFD session defaults to down";
              leaf start {
                type uint32 {
                  range "1..3600";
                }
                description
                  "The time since starting a BFD session before it is considered to have gone down";
              }

              leaf nbr-unconfig {
                type uint32 {
                  range "1..3600";
                }
                description
                  "The time since a BFD signalled that a peer session is unconfigured before it is considered to have gone down";
              }
            }  // container timers
          }  // container ipv4

          container ipv6 {
            description
              "Set configuration for the IPv6 address family";
            leaf destination {
              type inet:ipv6-address-no-zone;
              description
                "Set the destination address for the BFD session";
            }

            leaf minimum-interval {
              type uint32 {
                range "3..30000";
              }
              description
                "Set the preferred minimum interval for the BFD session";
            }

            leaf multiplier {
              type uint32 {
                range "2..50";
              }
              description
                "Set the preferred multiplier for the BFD session";
            }

            container fast-detect {
              presence
                "Indicates a fast-detect node is configured.";
              description
                "Enable fast detection using BFD on bundle members";
            }  // container fast-detect

            container timers {
              description
                "Set the timers that determine when a BFD session defaults to down";
              leaf start {
                type uint32 {
                  range "1..3600";
                }
                description
                  "The time since starting a BFD session before it is considered to have gone down";
              }

              leaf nbr-unconfig {
                type uint32 {
                  range "1..3600";
                }
                description
                  "The time since a BFD signalled that a peer session is unconfigured before it is considered to have gone down";
              }
            }  // container timers
          }  // container ipv6
        }  // container address-family

        container mode {
          must "cisco or ietf";
          presence
            "Indicates a mode node is configured.";
          description
            "Standard used for per-member BFD";
          container cisco {
            presence
              "Indicates a cisco node is configured.";
            description
              "Use Cisco standard for BoB";
          }  // container cisco

          container ietf {
            presence
              "Indicates a ietf node is configured.";
            description
              "Use IETF standard for BoB";
          }  // container ietf
        }  // container mode
      }  // container bfd

      container lacp {
        tailf:dependency "../a1:interface-name";
        when
          "../a1:interface-name[starts-with(text(),'GigabitEthernet')] or ../a1:interface-name[starts-with(text(),'TenGigE')] or ../a1:interface-name[starts-with(text(),'FortyGigE')] or ../a1:interface-name[starts-with(text(),'HundredGigE')] or ../a1:interface-name[starts-with(text(),'TwoHundredGigE')] or ../a1:interface-name[starts-with(text(),'FourHundredGigE')] or ../a1:interface-name[starts-with(text(),'TwentyFiveGigE')] or ../a1:interface-name[starts-with(text(),'FiftyGigE')] or ../a1:interface-name[starts-with(text(),'Bundle-')]";
        description
          "Bundle interface LACP commands";
        container switchover {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          description
            "Modify behavior for switching between links in this bundle";
          leaf suppress-flaps {
            type uint32 {
              range "100..65535";
            }
            description
              "Set the time for which to suppress flaps during a LACP switchover";
          }
        }  // container switchover

        container churn {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          description
            "Settings for LACP churn detection";
          leaf logging {
            type enumeration {
              enum "actor" {
                value 1;
                description
                  "Log actor churn events only";
              }
              enum "partner" {
                value 2;
                description
                  "Log partner churn events only";
              }
              enum "both" {
                value 3;
                description
                  "Log actor and partner churn events";
              }
            }
            description
              "Set parameters for logging of churn events";
          }
        }  // container churn

        leaf collector-max-delay {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          type uint32 {
            range "0..65535";
          }
          description
            "Collector max delay to be signaled to the LACP partner";
        }

        container timeout {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          description
            "Set timeout values for LACP-related timers";
          leaf rx-default {
            type uint32 {
              range "0..3000";
            }
            description
              "Set the timeout between expired and defaulted states";
          }

          leaf actor-churn {
            type uint32 {
              range "0..120";
            }
            description
              "Set the timeout to use before declaring actor churn";
          }

          leaf partner-churn {
            type uint32 {
              range "0..120";
            }
            description
              "Set the timeout to use before declaring partner churn";
          }
        }  // container timeout

        container cisco {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          description
            "Cisco LACP extensions";
          container enable {
            presence
              "Indicates a enable node is configured.";
            description
              "Enable the use of Cisco LACP extensions";
            container link-order {
              description
                "Link ordering numbers processing";
              container signaled {
                presence
                  "Indicates a signaled node is configured.";
                description
                  "Turn on processing of link ordering numbers";
              }  // container signaled
            }  // container link-order
          }  // container enable
        }  // container cisco

        container non-revertive {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          presence
            "Indicates a non-revertive node is configured.";
          description
            "Set the bundle to lacp non-revertive mode";
        }  // container non-revertive

        leaf mode {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          type enumeration {
            enum "on" {
              value 0;
              description
                "Do not run LACP over the port.";
            }
            enum "active" {
              value 1;
              description
                "Run LACP in active mode over the port.";
            }
            enum "passive" {
              value 2;
              description
                "Run LACP in passive mode over the port.";
            }
          }
          description
            " Set the LACP mode on bundle to be used by its member link";
        }

        container system {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'Bundle-')]";
          description
            "Set the default system parameters for LACP bundles";
          leaf priority {
            type uint32 {
              range "1..65535";
            }
            description
              "The system priority to use in LACP negotiations.";
          }

          leaf mac {
            type yang:mac-address;
            description
              "Configure the system ID to use in LACP negotiations for this bundle.";
          }
        }  // container system

        container period {
          must "transmission-id or short";
          presence
            "Indicates a period node is configured.";
          description
            "Set the period on bundle to be used by its member link";
          leaf transmission-id {
            type uint32 {
              range "2..30000";
            }
            description
              " Set the period on bundle to be used by its member link";
          }

          container short {
            presence
              "Indicates a short node is configured.";
            description
              "set the short period on bundle";
          }  // container short
        }  // container period

        leaf default-threshold {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'GigabitEthernet')] or ../../a1:interface-name[starts-with(text(),'TenGigE')] or ../../a1:interface-name[starts-with(text(),'FortyGigE')] or ../../a1:interface-name[starts-with(text(),'HundredGigE')] or ../../a1:interface-name[starts-with(text(),'TwoHundredGigE')] or ../../a1:interface-name[starts-with(text(),'FourHundredGigE')] or ../../a1:interface-name[starts-with(text(),'TwentyFiveGigE')] or ../../a1:interface-name[starts-with(text(),'FiftyGigE')]";
          type uint32 {
            range "1..3";
          }
          description
            "Set the LACP packet default threshold";
        }

        leaf expire-threshold {
          tailf:dependency "../../a1:interface-name";
          when
            "../../a1:interface-name[starts-with(text(),'GigabitEthernet')] or ../../a1:interface-name[starts-with(text(),'TenGigE')] or ../../a1:interface-name[starts-with(text(),'FortyGigE')] or ../../a1:interface-name[starts-with(text(),'HundredGigE')] or ../../a1:interface-name[starts-with(text(),'TwoHundredGigE')] or ../../a1:interface-name[starts-with(text(),'FourHundredGigE')] or ../../a1:interface-name[starts-with(text(),'TwentyFiveGigE')] or ../../a1:interface-name[starts-with(text(),'FiftyGigE')]";
          type uint32 {
            range "1..3";
          }
          description
            "Set the LACP packet expire threshold";
        }
      }  // container lacp

      container mlacp {
        tailf:dependency "../a1:interface-name";
        when
          "../a1:interface-name[starts-with(text(),'Bundle-')]";
        description
          "Multi-chassis LACP per-interface commands";
        leaf iccp-group {
          type uint32 {
            range "1..4294967295";
          }
          description
            "ICCP redundancy group related commands for this bundle.";
        }

        leaf port-priority {
          type uint32 {
            range "1..65535";
          }
          description
            "Set the priority for all member links on this device when running mLACP.";
        }

        container switchover {
          description
            "Set the parameters for performing a switchover to/from the mLACP peer";
          leaf type {
            type enumeration {
              enum "brute-force" {
                value 1;
                description
                  "Force switchover by disabling all local member links";
              }
              enum "revertive" {
                value 2;
                description
                  "Revert based on configured priority values";
              }
            }
            description
              "Set the type of switchover operation to use";
          }

          container maximize {
            description
              "Parameters for switchover behavior to maximize operational links/bandwidth";
            container links {
              presence
                "Indicates a links node is configured.";
              description
                "Compare the number of operational links";
              leaf threshold {
                type uint32 {
                  range "1..64";
                }
                description
                  "Set the threshold below which to switch to the peer if it has more links available";
              }
            }  // container links

            container bandwidth {
              presence
                "Indicates a bandwidth node is configured.";
              description
                "Compare the total bandwidth of operational links";
              leaf threshold {
                type uint64 {
                  range
                    "1..18446744073709551615";
                }
                description
                  "Set the threshold below which to switch to the peer if it has more bandwidth available";
              }
            }  // container bandwidth
          }  // container maximize

          leaf recovery-delay {
            type uint32 {
              range "0..65535";
            }
            description
              "Specify delay before bundle becoming active after recovery from failure";
          }
        }  // container switchover
      }  // container mlacp
    }  // grouping GROUP-BUNDLE

    augment /a1:interfaces/a1:interface {
      uses GROUP-BUNDLE;
    }

    augment /a1:interfaces/a1:interface-preconfigure {
      uses GROUP-BUNDLE;
    }
  }  // module Cisco-IOS-XR-um-if-bundle-cfg