module Cisco-IOS-XR-um-bfd-sbfd-cfg {

    yang-version 1;

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

    prefix um-bfd-sbfd-cfg;

    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-um-snmp-server-cfg {
      prefix a1;
    }
    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems, Inc.";

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

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

    revision "2020-12-18" {
      description "Initial release";
    }

    semver:module-version "1.0.0";

    container bfd {
      description
        "Global BFD configuration commands";
      container echo {
        description
          "Configure BFD echo parameters";
        container disable {
          presence
            "Indicates a disable node is configured.";
          description
            "Disable BFD echo mode";
        }  // container disable

        container latency {
          description
            "Configure BFD echo latency features";
          container detect {
            presence
              "Indicates a detect node is configured.";
            description
              "Enable BFD echo latency detection";
            leaf percentage {
              type uint32 {
                range "100..250";
              }
              description
                "Percentage of detection time to consider as bad latency";
            }

            leaf count {
              type uint32 {
                range "1..10";
              }
              must "../percentage";
              description
                "Count of consecutive bad latency packets to take session down";
            }
          }  // container detect
        }  // container latency

        container startup {
          description
            "Configure BFD echo startup feature";
          container validate {
            presence
              "Indicates a validate node is configured.";
            description
              "Enable BFD echo validation prior to session bringup";
            container force {
              presence
                "Indicates a force node is configured.";
              description
                "Ignore remote 'Required Min Echo RX Interval' setting";
            }  // container force
          }  // container validate
        }  // container startup

        container ipv4 {
          description "IPv4 commands";
          leaf source {
            type inet:ipv4-address-no-zone;
            description
              "BFD echo source IP address";
          }

          container bundle-per-member {
            description
              "Configure echo for all the micro BFD sessions over Bundles";
            container minimum-interval {
              description
                "Set the preferred minimum interval for the BFD session";
              leaf preferred-minimum-interval {
                type uint32 {
                  range "15..2000";
                }
                description
                  "The preferred minimum interval (in ms) for the BFD session";
              }
            }  // container minimum-interval
          }  // container bundle-per-member
        }  // container ipv4
      }  // container echo

      container trap {
        description
          "Configure BFD trap parameters";
        container singlehop {
          description "Configure BFD mode";
          container pre-mapped {
            presence
              "Indicates a pre-mapped node is configured.";
            description
              "Configure BFD trap pre-mapped";
          }  // container pre-mapped
        }  // container singlehop
      }  // container trap

      container multipath {
        description
          "Configure BFD multiple path";
        container include {
          description "Include a LC node";
          container locations {
            description "Specify a location";
            list location {
              key "location-name";
              description
                "Specify a location";
              leaf location-name {
                type xr:Node-id;
                description
                  "Specify a location";
              }
            }  // list location
          }  // container locations
        }  // container include
      }  // container multipath

      container multihop {
        description "Configure BFD multihop";
        leaf ttl-drop-threshold {
          type uint32 {
            range "0..254";
          }
          description "TTL Drop Threshold";
        }
      }  // container multihop

      container dampening {
        description
          "Configure BFD dampening intervals";
        leaf initial-wait {
          type uint32 {
            range "1..3600000";
          }
          description
            "Initial delay before bringing up session";
        }

        leaf secondary-wait {
          type uint32 {
            range "1..3600000";
          }
          description
            "Secondary delay before bringing up session";
        }

        leaf maximum-wait {
          type uint32 {
            range "1..3600000";
          }
          description
            "Maximum delay before bringing up session";
        }

        leaf threshold {
          type uint32 {
            range "60000..3600000";
          }
          description
            "Stability threshold to enable dampening";
        }

        container extensions {
          description
            "Enable dampening extensions";
          container down-monitoring {
            presence
              "Indicates a down-monitoring node is configured.";
            description
              "Enable DOWN state session monitoring extensions";
          }  // container down-monitoring
        }  // container extensions

        container disable {
          presence
            "Indicates a disable node is configured.";
          description
            "Disable BFD dampening";
        }  // container disable

        container bundle-member {
          description
            "Configure BFD dampening for bfd over bundle per member feature";
          container l3-only-mode {
            presence
              "Indicates a l3-only-mode node is configured.";
            description
              "Apply immediate dampening and only when failure is L3 specific";
          }  // container l3-only-mode

          leaf initial-wait {
            type uint32 {
              range "1..518400000";
            }
            description
              "Initial delay before bringing up session";
          }

          leaf secondary-wait {
            type uint32 {
              range "1..518400000";
            }
            description
              "Secondary delay before bringing up session";
          }

          leaf maximum-wait {
            type uint32 {
              range "1..518400000";
            }
            description
              "Maximum delay before bringing up session";
          }
        }  // container bundle-member
      }  // container dampening

      container bundle {
        description
          "Option for BFD over Bundle";
        container coexistence {
          description
            "How BFD bundle features coexist";
          container bob-blb {
            description
              "Coexistence for BoB and BLB";
            container inherit {
              must "not(../logical)";
              presence
                "Indicates a inherit node is configured.";
              description
                "Use inheritence mechanism";
            }  // container inherit

            container logical {
              must "not(../inherit)";
              presence
                "Indicates a logical node is configured.";
              description
                "Use BFD logical Bundle natively";
            }  // container logical
          }  // container bob-blb
        }  // container coexistence
      }  // container bundle

      container interfaces {
        description
          "Configure BFD on an interface";
        list interface {
          key "interface-name";
          description
            "Configure BFD on an interface";
          leaf interface-name {
            type xr:Interface-name;
            description
              "Configure BFD on an interface";
          }

          container echo {
            presence
              "Indicates a echo node is configured.";
            description
              "Configure BFD echo mode";
            container disable {
              presence
                "Indicates a disable node is configured.";
              description
                "Disable BFD echo mode for this interface";
            }  // container disable

            container ipv4 {
              description "IPv4 commands";
              leaf source {
                type inet:ipv4-address-no-zone;
                description
                  "BFD echo source IP address";
              }
            }  // container ipv4
          }  // container echo

          container ipv6 {
            description
              "Configure BFD ipv6 checksum mode";
            container checksum {
              presence
                "Indicates a checksum node is configured.";
              description
                "IPv6 checksum commands";
              container disable {
                presence
                  "Indicates a disable node is configured.";
                description
                  "Disable BFD ipv6 checksum mode for this interface";
              }  // container disable
            }  // container checksum
          }  // container ipv6

          container disable {
            presence
              "Indicates a disable node is configured.";
            description
              "Disable BFD for this interface";
          }  // container disable

          leaf local-address {
            type inet:ip-address-no-zone;
            description
              "Local address to be used by BFD for this interface";
          }

          leaf tx-interval {
            type uint32 {
              range "3000..30000000";
            }
            description
              "BFD TX Interval for this interface in microseconds";
          }

          leaf rx-interval {
            type uint32 {
              range "3000..30000000";
            }
            description
              "BFD RX Interval for this interface in microseconds";
          }

          leaf multiplier {
            type uint32 {
              range "2..50";
            }
            description
              "BFD multiplier for this interface";
          }
        }  // list interface
      }  // container interfaces

      container ipv6 {
        description "Ipv6 BFD checksum";
        container checksum {
          description
            "Configure BFD checksum parameters";
          container disable {
            presence
              "Indicates a disable node is configured.";
            description
              "Disable BFD checksum";
          }  // container disable
        }  // container checksum
      }  // container ipv6
    }  // container bfd

    container sbfd {
      description
        "Global SBFD configuration commands";
      container local-discriminator {
        description
          "configure local-discriminator";
        container local-discriminators {
          description
            "32-bit local-discriminator";
          list local-discriminator {
            key "local-discriminator-value";
            description
              "32-bit local-discriminator";
            leaf local-discriminator-value {
              type uint32 {
                range "1..4294967295";
              }
              description
                "32-bit local-discriminator";
            }
          }  // list local-discriminator
        }  // container local-discriminators

        container ip-addresses {
          description
            "ipv4 address as local-discriminator";
          list ip-address {
            key "address";
            description
              "ipv4 address as local-discriminator";
            leaf address {
              type inet:ipv4-address-no-zone;
              description
                "ipv4 address as local-discriminator";
            }
          }  // list ip-address
        }  // container ip-addresses

        container dynamic {
          presence
            "Indicates a dynamic node is configured.";
          description
            "configure local-discriminator dynamically";
        }  // container dynamic

        container interfaces {
          description
            "Interface whose IPv4 address is to be used as local discriminator";
          list interface {
            key "interface-name";
            description
              "Interface whose IPv4 address is to be used as local discriminator";
            leaf interface-name {
              type xr:Interface-name;
              description
                "Interface whose IPv4 address is to be used as local discriminator";
            }
          }  // list interface
        }  // container interfaces
      }  // container local-discriminator

      container remote-target {
        description
          "configure remote-target";
        container ipv4s {
          description "Ipv4 address only";
          list ipv4 {
            key "address";
            description "Ipv4 address only";
            leaf address {
              type inet:ipv4-address-no-zone;
              description
                "Ipv4 address only";
            }

            container remote-discriminators {
              description
                "Configure remote-discriminator";
              list remote-discriminator {
                key "remote-discriminator-value";
                description
                  "32-bit remote-discriminator";
                leaf remote-discriminator-value {
                  type uint32 {
                    range "1..4294967295";
                  }
                  description
                    "32-bit remote-discriminator";
                }
              }  // list remote-discriminator
            }  // container remote-discriminators
          }  // list ipv4
        }  // container ipv4s

        container ipv6s {
          description "Ipv6 address only";
          list ipv6 {
            key "address";
            description "Ipv6 address only";
            leaf address {
              type inet:ipv6-address-no-zone;
              description
                "Ipv6 address only";
            }

            container remote-discriminators {
              description
                "Configure remote-discriminator";
              list remote-discriminator {
                key "remote-discriminator-value";
                description
                  "32-bit remote-discriminator";
                leaf remote-discriminator-value {
                  type uint32 {
                    range "1..4294967295";
                  }
                  description
                    "32-bit remote-discriminator";
                }
              }  // list remote-discriminator
            }  // container remote-discriminators
          }  // list ipv6
        }  // container ipv6s
      }  // container remote-target
    }  // container sbfd
  }  // module Cisco-IOS-XR-um-bfd-sbfd-cfg