// SPDX-License-Identifier: BSD-2-Clause
module frr-isisd {
  yang-version 1.1;
  namespace "http://frrouting.org/yang/isisd";
  prefix frr-isisd;

  import ietf-yang-types {
    prefix yang;
  }

  import ietf-inet-types {
    prefix inet;
  }

  import frr-interface {
    prefix frr-interface;
  }

  import frr-vrf {
    prefix frr-vrf;
  }

  import frr-route-map {
    prefix frr-route-map;
  }

  import frr-route-types {
    prefix frr-route-types;
  }

  organization
    "FRRouting";
  contact
    "FRR Users List: <mailto:frog@lists.frrouting.org> FRR Development
     List: <mailto:dev@lists.frrouting.org>";
  description
    "This module defines a model for managing FRR isisd daemon.

     Copyright 2020 FRRouting

     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions
     are met:

     1. Redistributions of source code must retain the above copyright notice,
     this list of conditions and the following disclaimer.

     2. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.

     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.";

  revision 2021-02-15 {
    description
      "Group SRGB and SRLB in a container so that they can be displayed
       and configured together";
  }
  revision 2020-04-06 {
    description
      "Group LSP timers in a container so that they can be displayed and
       configured together";
  }
  revision 2019-12-17 {
    description
      "Changed default area is-type to level-1-2";
  }
  revision 2019-09-09 {
    description
      "Changed interface references to use
       frr-interface:interface-ref typedef";
  }
  revision 2018-07-26 {
    description
      "Initial revision.";
    reference
      "ISO/IEC 10589:2002.";
  }

  typedef level {
    type enumeration {
      enum "level-1" {
        value 1;
        description
          "This enum indicates L1-only capability.";
      }
      enum "level-2" {
        value 2;
        description
          "This enum indicates L2-only capability.";
      }
      enum "level-1-2" {
        value 3;
        description
          "This enum indicates capability for both levels.";
      }
    }
    description
      "This type defines IS-IS level of an object.";
  }

  typedef extended-circuit-id {
    type uint32;
    description
      "This type defines the extended circuit ID
       associated with an interface.";
  }

  typedef hello-padding-type {
    type enumeration {
      enum "always" {
        value 0;
        description
          "Add padding to all hello packets.";
      }
      enum "disabled" {
        value 1;
        description
          "Do not add any padding to hello packets.";
      } 
      enum "during-adjacency-formation" {
        value 2;
        description
          "Add padding to hello packets during adjacency formation only.";
      }
    }
  }

  typedef network-type {
    type enumeration {
      enum "unknown" {
        value 0;
        description
          "Unknown network type. Only valid as a state.";
      }
      enum "broadcast" {
        value 1;
        description
          "Broadcast circuit network-type.";
      }
      enum "point-to-point" {
        value 2;
        description
          "Point-to-point circuit network-type.";
      }
      enum "loopback" {
        value 3;
        description
          "Loopback circuit network-type. Only valid as a state.";
      }
    }
  }

  typedef lsp-id {
    type string {
      pattern "[0-9A-Fa-f]{4}\\.[0-9A-Fa-f]{4}\\.[0-9A-Fa-f]{4}\\.[0-9][0-9]-[0-9][0-9]";
    }
    description
      "This type defines the IS-IS LSP ID format using a
       pattern, An example LSP ID is 0143.0438.AeF0.02-01";
  }

  typedef snpa {
    type string {
      length "0 .. 20";
    }
    description
      "This type defines the Subnetwork Point
       of Attachment (SNPA) format.
       The SNPA should be encoded according to the rules
       specified for the particular type of subnetwork
       being used. As an example, for an ethernet subnetwork,
       the SNPA is encoded as a MAC address like
       '00aa.bbcc.ddee'.";
  }

  typedef system-id {
    type string {
      pattern "[0-9A-Fa-f]{4}\\.[0-9A-Fa-f]{4}\\.[0-9A-Fa-f]{4}";
    }
    description
      "This type defines IS-IS system-id using a pattern,
       An example system-id is 0143.0438.AeF0";
  }

  typedef net-address {
    type string {
      pattern "[a-fA-F0-9]{2}(\\.[a-fA-F0-9]{4}){3,9}\\.[a-fA-F0-9]{2}";
    }
    description
      "This type defines an OSI NET address using a pattern,
       An example net-address is 49.0123.6452.1972.00";
  }

  typedef if-state-type {
    type enumeration {
      enum "up" {
        value 0;
        description
          "Up state.";
      }
      enum "down" {
        value 1;
        description
          "Down state";
      }
    }
    description
      "This type defines the state of an interface";
  }

  typedef adj-state-type {
    type enumeration {
      enum "up" {
        value 0;
        description
          "State indicates the adjacency is established.";
      }
      enum "down" {
        value 1;
        description
          "State indicates the adjacency is NOT established.";
      }
      enum "init" {
        value 2;
        description
          "State indicates the adjacency is establishing.";
      }
      enum "failed" {
        value 3;
        description
          "State indicates the adjacency is failed.";
      }
    }
    description
      "This type defines states of an adjacency";
  }

  typedef metric-style-type {
    type enumeration {
      enum "narrow" {
        value 0;
        description
          "This enum describes narrow metric style";
        reference
          "RFC1195";
      }
      enum "wide" {
        value 1;
        description
          "This enum describes wide metric style";
        reference
          "RFC5305";
      }
      enum "transition" {
        value 2;
        description
          "This enum describes transition metric style";
      }
    }
  }

  typedef access-list-ref {
    type string;
  }

  typedef prefix-list-ref {
    type string;
  }

  grouping redistribute-attributes {
    description
      "Common optional attributes of any redistribute entry.";
    leaf route-map {
      type frr-route-map:route-map-ref;
      description
        "Applies the conditions of the specified route-map to routes that
         are redistributed into this routing instance.";
    }

    leaf metric {
      type uint32 {
        range "0..16777215";
      }
      default "0";
      description
        "Metric used for the redistributed route. If 0,
         the default-metric attribute is used instead.";
    }
  }

  grouping redistribute-default {
    description
      "Redistribution of default route within a level.";
    leaf always {
      type boolean;
      default "false";
      description
        "Always advertise default route.";
    }

    uses redistribute-attributes;
  }

  grouping isis-password {
    description
      "Authentication attributes or an IS-IS area or domain.";
    leaf password {
      type string {
        length "1..254";
      }
      mandatory true;
      description
        "Actual password.";
    }

    leaf password-type {
      type enumeration {
        enum "clear" {
          value 1;
          description
            "Clear-text password type.";
        }
        enum "md5" {
          value 54;
          description
            "MD5 password type.";
        }
      }
      mandatory true;
      description
        "Type of password used.";
    }
  }

  grouping isis-area-password {
    uses isis-password;

    leaf authenticate-snp {
      type enumeration {
        enum "none" {
          value 0;
          description
            "No SNP authentication.";
        }
        enum "send-only" {
          value 1;
          description
            "Send authenticated PDUs but do not check on receiving.";
        }
        enum "validate" {
          value 3;
          description
            "Send authenticated PDUs and check on receiving.";
        }
      }
      default "none";
      description
        "SNP PDUs authentication.";
    }
  }

  grouping global-config-lfa {
    container lfa {
      description
        "LFA configuration.";

      leaf load-sharing {
        type boolean;
        default "true";
        description
          "Load share prefixes across multiple backups.";
      }
      leaf priority-limit {
        type enumeration {
          enum "critical" {
            value 0;
            description
              "Compute for critical priority prefixes only.";
          }
          enum "high" {
            value 1;
            description
              "Compute for critical & high priority prefixes.";
          }
          enum "medium" {
            value 2;
            description
              "Compute for critical, high & medium priority prefixes.";
          }
        }
        description
          "Limit backup computation up to the prefix priority.";
      }
      list tiebreaker {
        key "index";
        unique "type";
        description
          "Configure tiebreaker for multiple backups.";
        leaf index {
          type uint8 {
            range "1..255";
          }
          description
            "Preference order among tiebreakers.";
        }
        leaf type {
          type enumeration {
            enum "downstream" {
              value 0;
              description
                "Prefer backup path via downstream node.";
            }
            enum "lowest-backup-metric" {
              value 1;
              description
                "Prefer backup path with lowest total metric.";
            }
            enum "node-protecting" {
              value 2;
              description
                "Prefer node protecting backup path.";
            }
          }
          mandatory true;
          description
            "Tiebreaker type.";
        }
      }
    }
  }

  grouping global-config-remote-lfa {
    container remote-lfa {
      description
        "Remote LFA configuration.";

      leaf prefix-list {
        type prefix-list-ref;
        description
          "Filter PQ node router ID based on prefix list.";
      }
    }
  }

  grouping interface-config-lfa {
    container lfa {
      description
        "LFA configuration.";
      leaf enable {
        type boolean;
        default false;
        description
          "Enables LFA computation.";
      }
      leaf-list exclude-interface {
        type frr-interface:interface-ref;
        description
          "Exclude an interface from computation.";
      }
    }
  }

  grouping interface-config-remote-lfa {
    container remote-lfa {
      description
        "Remote LFA configuration.";

      leaf enable {
        type boolean;
        default false;
        description
          "Enables remote LFA computation using LDP tunnels.";
        must ". = 'false' or ../../lfa/enable = 'true'" {
          error-message
            "Remote LFA depends on classic LFA being configured in the interface.";
        }

      }
      leaf maximum-metric {
        type uint32 {
          range "1..16777215";
        }
        description
          "Limit remote LFA node selection within the metric.";
      }
    }
  }

  grouping interface-config-ti-lfa {
    container ti-lfa {
      description
        "TI-LFA configuration.";
      leaf enable {
        must ". = 'false' or ../../lfa/enable = 'false'" {
          error-message
            "Can't enable both classic LFA and TI-LFA in the same interface.";
        }
        type boolean;
        default false;
        description
          "Enables TI-LFA computation.";
      }
      leaf node-protection {
        type boolean;
        must ". = 'false' or ../enable = 'true'";
        default false;
        description
          "Node protection is provided by the alternate.";
      }
      leaf link-fallback {
        type boolean;
        must ". = 'false' or ../enable = 'true'";
        default false;
        description
          "Fallback to link protection.";
      }
    }
  }

  grouping interface-config {
    description
      "Interface configuration grouping";
    leaf area-tag {
      type string;
      mandatory true;
      description
        "Area-tag associated to this circuit.";
    }

    leaf ipv4-routing {
      type boolean;
      default "false";
      description
        "Routing IS-IS IPv4 traffic over this circuit.";
    }

    leaf ipv6-routing {
      type boolean;
      default "false";
      description
        "Routing IS-IS IPv6 traffic over this circuit.";
    }

    leaf circuit-type {
      type level;
      default "level-1-2";
      description
        "IS-type of this circuit.";
    }

    container bfd-monitoring {
      leaf enabled {
        type boolean;
        default "false";
        description
          "Monitor IS-IS peers on this circuit.";
      }
      leaf profile {
        type string;
        description
          "Let BFD use a pre-configured profile.";
      }
    }

    container csnp-interval {
      description
        "Complete Sequence Number PDU (CSNP) generation interval.";
      leaf level-1 {
        type uint16 {
          range "1..600";
        }
        units "seconds";
        default "10";
        description
          "CNSP interval for level-1";
      }

      leaf level-2 {
        type uint16 {
          range "1..600";
        }
        units "seconds";
        default "10";
        description
          "CNSP interval for level-2";
      }
    }

    container psnp-interval {
      description
        "Partial Sequence Number PDU (PSNP) generation interval.";
      leaf level-1 {
        type uint16 {
          range "1..120";
        }
        units "seconds";
        default "2";
        description
          "PNSP interval for level-1";
      }

      leaf level-2 {
        type uint16 {
          range "1..120";
        }
        units "seconds";
        default "2";
        description
          "PCNSP interval for level-2";
      }
    }

    container hello {
      description
        "Parameters related to IS-IS hello PDUs.";
      leaf padding {
        type hello-padding-type;
        default "always";
        description
          "Type of padding for IS-IS hello packets.";
      }

      container interval {
        description
          "Interval between consecutive hello messages.";
        leaf level-1 {
          type uint32 {
            range "1..600";
          }
          units "seconds";
          default "3";
          description
            "Holding time for level-1; interval will depend on multiplier.";
        }

        leaf level-2 {
          type uint32 {
            range "1..600";
          }
          units "seconds";
          default "3";
          description
            "Holding time for level-2; interval will depend on multiplier.";
        }
      }

      container multiplier {
        description
          "Multiplier for the hello messages holding time.";
        leaf level-1 {
          type uint16 {
            range "2..100";
          }
          default "10";
          description
            "Multiplier for the hello holding time.";
        }

        leaf level-2 {
          type uint16 {
            range "2..100";
          }
          default "10";
          description
            "Multiplier for the hello holding time.";
        }
      }
    }

    container metric {
      description
        "Default metric for this IS-IS circuit.";
      leaf level-1 {
        type uint32 {
          range "0..16777215";
        }
        must ". < 64 or /frr-isisd:isis/instance[area-tag = current()/../../area-tag]/metric-style = 'wide' or not(/frr-isisd:isis/instance[area-tag = current()/../../area-tag]/metric-style)";
        default "10";
        description
          "Default level-1 metric for this IS-IS circuit.";
      }

      leaf level-2 {
        type uint32 {
          range "0..16777215";
        }
        must ". < 64 or /frr-isisd:isis/instance[area-tag = current()/../../area-tag]/metric-style = 'wide' or not(/frr-isisd:isis/instance[area-tag = current()/../../area-tag]/metric-style)";
        default "10";
        description
          "Default level-2 metric for this IS-IS circuit.";
      }
    }

    container priority {
      description
        "Priority for Designated Router election.";
      leaf level-1 {
        type uint8 {
          range "0..127";
        }
        default "64";
        description
          "Level-1 priority for this IS-IS circuit.";
      }

      leaf level-2 {
        type uint8 {
          range "0..127";
        }
        default "64";
        description
          "Level-2 priority for this IS-IS circuit.";
      }
    }

    leaf network-type {
      type network-type;
      must "(. = \"point-to-point\") or (. = \"broadcast\")";
      default "broadcast";
      description
        "Explicitly configured type of IS-IS circuit (broadcast or point-to-point).";
    }

    leaf passive {
      type boolean;
      default "false";
      description
        "Interface is in passive mode.";
    }

    container password {
      presence "Present if a password is set for this IS interface.";
      uses isis-password;
    }

    leaf disable-three-way-handshake {
      type boolean;
      default "false";
      description
        "Disables three-way handshake when creating new adjacencies.";
    }

    container multi-topology {
      description
        "IS-IS topologies configured on this circuit.";
      leaf standard {
        type boolean;
        default "true";
        description
          "Standard (IPV4 unicast) topology.";
      }

      leaf ipv4-multicast {
        type boolean;
        default "true";
        description
          "IPv4 multicast topology.";
      }

      leaf ipv4-management {
        type boolean;
        default "true";
        description
          "IPv4 management topology.";
      }

      leaf ipv6-unicast {
        type boolean;
        default "true";
        description
          "IPv6 unicast topology.";
      }

      leaf ipv6-multicast {
        type boolean;
        default "true";
        description
          "IPv6 multicast topology.";
      }

      leaf ipv6-management {
        type boolean;
        default "true";
        description
          "IPv6 management topology.";
      }

      leaf ipv6-dstsrc {
        type boolean;
        default "true";
        description
          "IPv6 destination-source topology.";
      }
    }

    container mpls {
      description
        "Configuration of MPLS parameters";
      leaf ldp-sync {
        type boolean;
        default "true";
        description
          "Enable MPLS LDP-Sync functionality on this circuit.";
      }
      leaf holddown {
        type uint16 {
          range "0..10000";
        }
        units "seconds";
        description
          "Time to wait for LDP-Sync to occur before restoring interface metric.";
      }
    }

    container fast-reroute {
      description
        "Interface IP Fast-reroute configuration.";
      container level-1 {
        description
          "Level-1 IP Fast-reroute configuration.";
        uses interface-config-lfa;
        uses interface-config-remote-lfa;
        uses interface-config-ti-lfa;
      }
      container level-2 {
        description
          "Level-2 IP Fast-reroute configuration.";
        uses interface-config-lfa;
        uses interface-config-remote-lfa;
        uses interface-config-ti-lfa;
      }
    }
  }

  grouping adjacency-state {
    description
      "Adjacency state";
    container adjacencies {
      config false;
      description
        "This container lists the adjacencies of
         the local node.";
      list adjacency {
        description
          "List of operational adjacencies.";
        leaf neighbor-sys-type {
          type level;
          description
            "Level capability of neighboring system";
        }

        leaf neighbor-sysid {
          type system-id;
          description
            "The system-id of the neighbor";
        }

        leaf neighbor-extended-circuit-id {
          type extended-circuit-id;
          description
            "Circuit ID of the neighbor";
        }

        leaf neighbor-snpa {
          type snpa;
          description
            "SNPA of the neighbor";
        }

        leaf hold-timer {
          type uint16;
          units "seconds";
          description
            "The holding time in seconds for this
             adjacency. This value is based on
             received hello PDUs and the elapsed
             time since receipt.";
        }

        leaf neighbor-priority {
          type uint8 {
            range "0 .. 127";
          }
          description
            "Priority of the neighboring IS for becoming
             the DIS.";
        }

        leaf state {
          type adj-state-type;
          description
            "This leaf describes the state of the interface.";
        }

        uses adjacency-sids;
        uses lan-adjacency-sids;
      }
    }
  }

  grouping event-counters {
    description
      "Grouping for IS-IS interface event counters";
    container event-counters {
      config false;
      description
        "IS-IS interface event counters.";
      leaf adjacency-changes {
        type uint32;
        description
          "The number of times an adjacency state change has
           occurred on this interface.";
      }

      leaf adjacency-number {
        type uint32;
        description
          "The number of adjacencies on this interface.";
      }

      leaf init-fails {
        type uint32;
        description
          "The number of times initialization of this
           interface has failed. This counts events such
           as PPP NCP failures. Failures to form an
           adjacency are counted by adjacency-rejects.";
      }

      leaf adjacency-rejects {
        type uint32;
        description
          "The number of times an adjacency has been
           rejected on this interface.";
      }

      leaf id-len-mismatch {
        type uint32;
        description
          "The number of times an IS-IS PDU with an ID
           field length different from that for this
           system has been received on this interface.";
      }

      leaf max-area-addresses-mismatch {
        type uint32;
        description
          "The number of times an IS-IS PDU has been
           received on this interface with the
           max area address field differing from that of
           this system.";
      }

      leaf authentication-type-fails {
        type uint32;
        description
          "Number of authentication type mismatches.";
      }

      leaf authentication-fails {
        type uint32;
        description
          "Number of authentication key failures.";
      }
    }
  }

  grouping interface-state {
    description
      "IS-IS interface operational state.";
    uses adjacency-state;

    uses event-counters;
  }

  grouping notification-instance-hdr {
    description
      "Instance specific IS-IS notification data grouping";
    leaf routing-instance {
      type string;
      description
        "Name of the routing-instance instance.";
    }

    leaf routing-protocol-name {
      type string;
      description
        "Name of the IS-IS instance.";
    }

    leaf isis-level {
      type level;
      description
        "IS-IS level of the instance.";
    }
  }

  grouping notification-interface-hdr {
    description
      "Interface specific IS-IS notification data grouping";
    leaf interface-name {
      type frr-interface:interface-ref;
      description
        "IS-IS interface name";
    }

    leaf interface-level {
      type level;
      description
        "IS-IS level of the interface.";
    }

    leaf extended-circuit-id {
      type extended-circuit-id;
      description
        "Eextended circuit-id of the interface.";
    }
  }

  grouping adjacency-sids {
    description
      "IS-IS segment routing adjacency SID grouping.";
    container adjacency-sids {
      description
        "This container lists the information of adjacency SID.";
      list adjacency-sid {
        leaf af {
          type uint8;
          description
            "This leaf describes the protocol-family associated with the
              adjacency SID.";
        }

        leaf value {
          type uint32;
          description
            "This leaf describes the value of adjacency SID.";
        }

        leaf weight {
          type uint8;
          description
            "This leaf describes the weight of the adjacency SID.";
        }

        leaf protection-requested {
          type boolean;
          description
            "This leaf describes if the adjacency SID must be protected.";
        }
      }
    }
  }

  grouping lan-adjacency-sids {
    description
      "IS-IS segment routing LAN adjacency SID grouping.";
    container lan-adjacency-sids {
      description
        "This container lists the information of LAN adjacency SID.";
      list lan-adjacency-sid {
        leaf af {
          type uint8;
          description
            "This leaf describes the protocol-family associated with the
              LAN adjacency SID.";
        }

        leaf value {
          type uint32;
          description
            "This leaf describes the value of LAN adjacency SID.";
        }

        leaf weight {
          type uint8;
          description
            "This leaf describes the weight of the LAN adjacency SID.";
        }

        leaf protection-requested {
          type boolean;
          description
            "This leaf describes if the LAN adjacency SID must be protected.";
        }
      }
    }
  }

  container isis {
    description
      "Configuration of the IS-IS routing daemon.";
    list instance {
      key "area-tag vrf";
      description
        "IS-IS routing instance.";
      leaf area-tag {
        type string;
        description
          "Area-tag associated to this routing instance.";
      }

      leaf vrf {
        type frr-vrf:vrf-ref;
        description
          "VRF NAME.";
      }

      leaf is-type {
        type level;
        default "level-1-2";
        description
          "Level of the IS-IS routing instance (OSI only).";
      }

      leaf-list area-address {
        type net-address;
        max-elements 3;
        description
          "List of OSI NET addresses for this protocol instance.";
      }

      leaf dynamic-hostname {
        type boolean;
        default "true";
        description
          "Dynamic hostname support for IS-IS.";
      }

      leaf attach-send {
        type boolean;
        default "true";
        description
          "If true, attached bits are sent in LSP if L1/L2 router for inter-area traffic.";
      }

      leaf attach-receive-ignore {
        type boolean;
        default "false";
        description
          "If false, attached bits received in LSP, cause default route add, if L1 router for inter-area traffic.";
      }

      leaf attached {
        type boolean;
        default "false";
	status deprecated;
        description
          "If true, identify as L1/L2 router for inter-area traffic.";
      }

      container overload {
        description
          "Overload bit configuration.";
        leaf enabled {
          type boolean;
          default "false";
          description
            "If true, avoid any transit traffic.";
        }

        leaf on-startup {
          type uint32 {
            range "0..86400";
          }
          units "seconds";
          default "0";
          description
            "The duration the overload bit should be set on startup.";
        }
      }

      leaf metric-style {
        type metric-style-type;
        must ". = 'wide' or count(../multi-topology/*) = 0";
        default "wide";
        description
          "Define the style of TLVs metric supported.";
      }

      leaf advertise-high-metrics {
        type boolean;
        default "false";
        description
          "Advertise high metric value on all interfaces.";
      }

      leaf purge-originator {
        type boolean;
        default "false";
        description
          "Use the RFC 6232 purge-originator.";
        reference
          "RFC6232";
      }

      leaf advertise-passive-only {
        type boolean;
        default "false";
        description
          "Advertise prefixes of passive interfaces only";
      }

      leaf admin-group-send-zero {
        type boolean;
        default "false";
        description
          "Allow sending the default admin-group value of 0x00000000";
      }

      leaf asla-legacy-flag {
        type boolean;
        default "false";
        description
          "Set the legacy flag (aka. L-FLAG) in the ASLA Sub-TLV.";
      }

      container lsp {
        description
          "Configuration of Link-State Packets (LSP) parameters";
        leaf mtu {
          type uint16 {
            range "128..4352";
          }
          default "1497";
          description
            "MTU of an LSP.";
        }

        container timers {
          description
            "LSP-related timers";
          container level-1 {
            description
              "Level-1 LSP-related timers";
            leaf refresh-interval {
              type uint16;
              units "seconds";
              default "900";
              description
                "LSP refresh interval for level-1.";
            }

            leaf maximum-lifetime {
              type uint16 {
                range "350..65535";
              }
              units "seconds";
              must ". >= ../refresh-interval + 300";
              default "1200";
              description
                "Maximum LSP lifetime for level-1.";
            }

            leaf generation-interval {
              type uint16 {
                range "1..120";
              }
              units "seconds";
              must ". < ../refresh-interval";
              default "30";
              description
                "Minimum time allowed before level-1 LSP retransmissions.";
            }
          }

          container level-2 {
            description
              "Level-2 LSP-related timers";
            leaf refresh-interval {
              type uint16;
              units "seconds";
              default "900";
              description
                "LSP refresh interval for level-2.";
            }

            leaf maximum-lifetime {
              type uint16 {
                range "350..65535";
              }
              units "seconds";
              must ". >= ../refresh-interval + 300";
              default "1200";
              description
                "Maximum LSP lifetime for level-2.";
            }

            leaf generation-interval {
              type uint16 {
                range "1..120";
              }
              units "seconds";
              must ". < ../refresh-interval";
              default "30";
              description
                "Minimum time allowed before level-2 LSP retransmissions.";
            }
          }
        }
      }

      container spf {
        description
          "Parameters related to the Shortest Path First algorithm.";
        container ietf-backoff-delay {
          presence "Present if IETF SPF back-off delay is enabled.";
          description
            "SPF back-off delay algorithm parameters (see RFC 8405).";
          leaf init-delay {
            type uint16 {
              range "0..60000";
            }
            units "msec";
            mandatory true;
            description
              "Delay used while in QUIET state";
          }

          leaf short-delay {
            type uint16 {
              range "0..60000";
            }
            units "msec";
            mandatory true;
            description
              "Delay used while in SHORT_WAIT state";
          }

          leaf long-delay {
            type uint16 {
              range "0..60000";
            }
            units "msec";
            mandatory true;
            description
              "Delay used while in LONG_WAIT state";
          }

          leaf hold-down {
            type uint16 {
              range "0..60000";
            }
            units "msec";
            mandatory true;
            description
              "Time with no received IGP events before considering IGP stable";
          }

          leaf time-to-learn {
            type uint16 {
              range "0..60000";
            }
            units "msec";
            mandatory true;
            description
              "Maximum duration needed to learn all the events related to a
               single failure";
          }
        }

        container minimum-interval {
          description
            "Minimum interval between consecutive executions of the
             SPF algorithm.";
          leaf level-1 {
            type uint16 {
              range "1..120";
            }
            units "seconds";
            default "1";
            description
              "Minimum time between consecutive level-1 SPFs.";
          }

          leaf level-2 {
            type uint16 {
              range "1..120";
            }
            units "seconds";
            default "1";
            description
              "Minimum time between consecutive level-2 SPFs.";
          }
        }

        container prefix-priorities {
          description
            "SPF Prefix Priority configuration";

          container critical {
            description
              "Critical prefix priority";
            leaf access-list-name {
              type access-list-ref;
              description
                "Access List to determine prefixes for
                 this priority";
            }
          }
          container high {
            description
              "High prefix priority";
            leaf access-list-name {
              type access-list-ref;
              description
                "Access List to determine prefixes for
                 this priority";
            }
          }
          container medium {
            description
              "Medium prefix priority";
            leaf access-list-name {
              type access-list-ref;
              description
                "Access List to determine prefixes for
                 this priority";
            }
          }
        }
      }

      container area-password {
        presence "Present if authentication is required for IS level-1.";
        description
          "Authentication password for an IS-IS area.";
        uses isis-area-password;
      }

      container domain-password {
        presence "Present if authentication is required for IS level-2.";
        description
          "Authentication password for an IS-IS domain.";
        uses isis-area-password;
      }

      container default-information-originate {
        description
          "Distribution of default information.";
        list ipv4 {
          key "level";
          description
            "Distribute default route for IPv4.";
          leaf level {
            type level;
            must "(. != \"level-1-2\") and ((../../../is-type = \"level-1-2\") or (. = ../../../is-type))";
          }

          uses redistribute-default;
        }

        list ipv6 {
          key "level";
          description
            "Distribute default route for IPv6.";
          leaf level {
            type level;
            must "(. != \"level-1-2\") and ((../../../is-type = \"level-1-2\") or (. = ../../../is-type))";
          }

          uses redistribute-default;
        }
      }

      container redistribute {
        description
          "Redistributes routes learned from other routing protocols.";
        list ipv4 {
          key "protocol level";
          description
            "IPv4 route redistribution.";
          leaf protocol {
            type frr-route-types:frr-route-types-v4;
            must ". != \"isis\"";
            description
              "Originating routing protocol for the IPv4 routes.";
          }

          leaf level {
            type level;
            must "(. != \"level-1-2\") and ((../../../is-type = \"level-1-2\") or (. = ../../../is-type))";
            description
              "IS-IS level into which the routes should be redistributed.";
          }

          choice protocol-type {
            case protocol-table {
              when "./protocol = \"table\"";
              list table {
                key "table";
                when "../protocol = \"table\"";
                description
                  "Routing table number";

                leaf table {
                  type uint16 {
                     range "1..65535";
                  }
                  description
                    "Routing table number.";
                }

                uses redistribute-attributes;
              }
            }
            case protocol-other {
              uses redistribute-attributes;
            }
          }

        }
        list ipv6 {
          key "protocol level";
          description
            "IPv6 route redistribution.";
          leaf protocol {
            type frr-route-types:frr-route-types-v6;
            must ". != \"isis\"";
            description
              "Originating routing protocol for the IPv6 routes.";
          }

          leaf level {
            type level;
            must "(. != \"level-1-2\") and ((../../../is-type = \"level-1-2\") or (. = ../../../is-type))";
            description
              "IS-IS level into which the routes should be redistributed.";
          }

          choice protocol-type {
            case protocol-table {
              when "./protocol = \"table\"";
              list table {
                key "table";
                when "../protocol = \"table\"";

                leaf table {
                  type uint16 {
                     range "1..65535";
                  }
                  description
                    "Routing table number.";
                }

                uses redistribute-attributes;
              }
            }
            case protocol-other {
              uses redistribute-attributes;
            }
          }

        }
      }

      container multi-topology {
        description
          "IS-IS topologies configured for this area.";
        container ipv4-multicast {
          presence "Present if a separate IPv4-multicast topology is configured for this area.";
          description
            "IPv4 multicast topology.";
          leaf overload {
            type boolean;
            default "false";
          }
        }

        container ipv4-management {
          presence "Present if a separate IPv4-management topology is configured for this area.";
          description
            "IPv4 management topology.";
          leaf overload {
            type boolean;
            default "false";
          }
        }

        container ipv6-unicast {
          presence "Present if a separate IPv6-unicast topology is configured for this area.";
          description
            "IPv6 unicast topology.";
          leaf overload {
            type boolean;
            default "false";
          }
        }

        container ipv6-multicast {
          presence "Present if a separate IPv6-multicast topology is configured for this area.";
          description
            "IPv6 multicast topology.";
          leaf overload {
            type boolean;
            default "false";
          }
        }

        container ipv6-management {
          presence "Present if a separate IPv6-management topology is configured for this area.";
          description
            "IPv6 management topology.";
          leaf overload {
            type boolean;
            default "false";
          }
        }

        container ipv6-dstsrc {
          presence "Present if a separate IPv6 destination-source topology is configured for this area.";
          description
            "IPv6 destination-source topology.";
          leaf overload {
            type boolean;
            default "false";
          }
        }
      }

      container fast-reroute {
        description
          "IP Fast-reroute configuration.";
        container level-1 {
          description
            "Level-1 IP Fast-reroute configuration.";
          uses global-config-lfa;
          uses global-config-remote-lfa;
        }
        container level-2 {
          description
            "Level-2 IP Fast-reroute configuration.";
          uses global-config-lfa;
          uses global-config-remote-lfa;
        }
      }

      leaf log-adjacency-changes {
        type boolean;
        default "false";
        description
          "Log changes to the IS-IS adjacencies in this area.";
      }

      leaf log-pdu-drops {
        type boolean;
        default "false";
        description
          "Log any dropped PDUs in this area.";
      }

      container mpls-te {
        presence "Present if MPLS-TE is enabled.";
        description
          "Enable MPLS-TE functionality.";
        leaf router-address {
          type inet:ipv4-address;
          description
            "Stable IP address of the advertising router.";
        }
        leaf router-address-v6 {
          type inet:ipv6-address;
          description
            "Stable IPv6 address of the advertising router.";
        }
        leaf export {
          type boolean;
          default "false";
          description
            "Export Link State informatin.";
        }
      }

      container flex-algos {
        description
          "Flex-Algo Table";
        list flex-algo {
          key "flex-algo";
          description
            "Configuration for an IS-IS Flex-Algo";
          leaf advertise-definition {
            type boolean;
            description
              "If TRUE, Flex-Algo definition is advertised";
          }
          container affinity-include-alls {
            description
              "Set the include-all affinity";
            leaf-list affinity-include-all {
              type string;
              max-elements "256";
              description
                "Array of Attribute Names";
            }
          }
          container affinity-include-anies {
            description
              "Set the include-any affinity";
            leaf-list affinity-include-any {
              type string;
              max-elements "256";
              description
                "Array of Attribute Names";
            }
          }
          container affinity-exclude-anies {
            description
              "Set the exclude-any affinity";
            leaf-list affinity-exclude-any {
              type string;
              max-elements "256";
              description
                "Array of Attribute Names";
            }
          }
          leaf prefix-metric {
            type empty;
            description
              "Use Flex-algo Prefix Metric";
          }
          leaf metric-type {
            default "igp";
            description
              "Set the Flex-Algo metric-type";
		    type enumeration {
		      enum "igp" {
		        value 0;
			description
			  "IGP Metric";
		      }
		      enum "min-uni-link-delay" {
		        value 1;
			description
			  "RFC 8570 Sec 4.2 Min Unidirectional Link Delay";
		      }
		      enum "te-default" {
		        value 2;
			description
			  "RFC 5305 Sec 3.7 Traffic Engineering Default Metric";
		      }
		    }
          }
          leaf priority {
            type uint32 {
              range "0..255";
            }
            description
              "Set the Flex-Algo priority";
          }
          leaf dplane-sr-mpls {
            type empty;
            description
	          "Advertise and participate in the Flex-Algo Segment-Routing MPLS data-plane";
          }
          leaf dplane-srv6 {
            type empty;
            description
	          "Advertise and participate in the Flex-Algo Segment-Routing SRv6 data-plane";
          }
          leaf dplane-ip {
            type empty;
            description
	          "Advertise and participate in the Flex-Algo IP data-plane";
          }
          leaf flex-algo {
            type uint32 {
              range "128..255";
            }
            description
              "Flex-Algo";
          }
        }
      }

      container segment-routing {
        description
          "Segment Routing global configuration.";
        leaf enabled {
          type boolean;
          default "false";
          description
            "Enables segment-routing protocol extensions.";
        }
        container label-blocks {
          description
            "Local and global label blocks.";
          container srgb {
            description
              "Global blocks to be advertised.";
            leaf lower-bound {
                must "../upper-bound > .";
                type uint32;
                default "16000";
                description
                  "Lower value in the label range.";
            }
            leaf upper-bound {
                must ". > ../lower-bound";
                type uint32;
                default "23999";
                description
                  "Upper value in the label range.";
            }
          }
          container srlb {
            description
              "Local blocks to be advertised.";
            leaf lower-bound {
                must "../upper-bound > .";
                type uint32;
                default "15000";
                description
                  "Lower value in the label range.";
            }
            leaf upper-bound {
                must ". > ../lower-bound";
                type uint32;
                default "15999";
                description
                  "Upper value in the label range.";
            }
          }
        }
        container msd {
          description
            "MSD configuration.";
          leaf node-msd {
            type uint8;
            description
              "Node MSD is the lowest MSD supported by the node.";
          }
        }
        container prefix-sid-map {
          description
            "Prefix SID configuration.";
          list prefix-sid {
            key "prefix";
            unique "sid-value-type sid-value";
            description
              "List of prefix SID mapped to IPv4/IPv6
               local prefixes.";
            leaf prefix {
              type inet:ip-prefix;
              description
                "Connected prefix sid.";
            }
            leaf sid-value-type {
              type enumeration {
                enum "index" {
                  value 0;
                  description
                    "The value will be interpreted as an index.";
                }
                enum "absolute" {
                  value 1;
                  description
                    "The value will become interpreted as an absolute
                     value.";
                }
              }
              default "index";
              description
                "This leaf defines how value must be interpreted.";
            }
            leaf sid-value {
              type uint32;
              mandatory true;
              description
                "Value associated with prefix. The value must be
                 interpreted in the context of sid-value-type.";
            }
            leaf last-hop-behavior {
              type enumeration {
                enum "explicit-null" {
                  value 0;
                  description
                    "Use explicit-null for the SID.";
                }
                enum "no-php" {
                  value 1;
                  description
                    "Do not use Penultimate Hop Popping (PHP)
                     for the SID.";
                }
                enum "php" {
                  value 2;
                  description
                    "Use PHP for the SID.";
                }
              }
              default "php";
              description
                "Configure last hop behavior.";
            }
            leaf n-flag-clear {
              type boolean;
              default "false";
              description
                "Not a node SID";
            }
          }
        }
        container algorithm-prefix-sids {
          description
            "Algorithm SID Table";
          list algorithm-prefix-sid {
            key "prefix algo";
            description
              "Assign prefix SID for algorithm to an
               interface, ISISPHPFlag will be rejected
               if set to disable, ISISEXPLICITNULLFlag
               will override the value of ISISPHPFlag";
            leaf algo {
              type uint8 {
                range "128..255";
              }
              description
                "Algorithm";
            }
            leaf prefix {
              type inet:ip-prefix;
              mandatory true;
              description
                "Connected prefix sid.";
            }
            leaf sid-value-type {
              type enumeration {
                enum "index" {
                  value 0;
                  description
                    "The value will be interpreted as an index.";
                }
                enum "absolute" {
                  value 1;
                  description
                    "The value will become interpreted as an absolute
                     value.";
                }
              }
              default "index";
              description
                "This leaf defines how value must be interpreted.";
            }
            leaf sid-value {
              type uint32 {
                range "0..1048575";
              }
              mandatory true;
              description
                "Value associated with prefix. The value must be
                 interpreted in the context of sid-value-type.";
            }
            leaf last-hop-behavior {
              type enumeration {
                enum "explicit-null" {
                  value 0;
                  description
                    "Use explicit-null for the SID.";
                }
                enum "no-php" {
                  value 1;
                  description
                    "Do not use Penultimate Hop Popping (PHP)
                     for the SID.";
                }
                enum "php" {
                  value 2;
                  description
                    "Use PHP for the SID.";
                }
              }
              default "php";
              description
                "Configure last hop behavior.";
            }
            leaf n-flag-clear {
              type boolean;
              default "false";
              description
                "Not a node SID";
            }
          }
        }
      }

      container segment-routing-srv6 {
        description
          "Segment Routing over IPv6 (SRv6) global configuration.";
        leaf enabled {
          type boolean;
          default "false";
          description
            "Enable IS-IS extensions to support Segment Routing over
             IPv6 data plane (SRv6).";
          reference
            "RFC 9352";
        }
        leaf locator {
          type string;
          description
            "SRv6 locator.";
        }
        container msd {
          description
            "SRv6 Maximum SRv6 SID Depths.";
          container node-msd {
            description
              "SRv6 Node Maximum SRv6 SID Depths.";
            leaf max-segs-left {
              type uint8 {
                range "0..255";
              }
              default 3;
              description
               "Maximum Segments Left MSD.";
            }
            leaf max-end-pop {
              type uint8 {
                range "0..255";
              }
              default 3;
              description
               "Maximum End Pop MSD.";
            }
            leaf max-h-encaps {
              type uint8 {
                range "0..255";
              }
              default 2;
              description
               "Maximum H.Encaps MSD.";
            }
            leaf max-end-d {
              type uint8 {
                range "0..255";
              }
              default 5;
              description
               "Maximum End D MSD.";
            }
          }
        }
        leaf interface {
          type string;
          description
            "Dummy interface used to install SRv6 SIDs into the Linux data plane.";
          default "sr0";
        }
      }

      container mpls {
        description
          "Configuration of MPLS parameters";
        container ldp-sync {
          presence "Present if MPLS LDP-Sync is enabled.";
          description
            "Enable MPLS LDP-Sync functionality.";
          leaf holddown {
            type uint16 {
              range "0..10000";
            }
            units "seconds";
            default "0";
            description
              "Time to wait for LDP-Sync to occur before restoring interface metric.";
          }
        }
      }

    }
  }

  augment "/frr-interface:lib/frr-interface:interface" {
    description
      "Extends interface model with IS-IS related parameters.";
    container isis {
      presence "Present if an IS-IS circuit is defined for this interface.";
      description
        "IS-IS interface parameters.";
      uses interface-config;
    }
  }

  augment "/frr-interface:lib/frr-interface:interface/frr-interface:state" {
    description
      "Extends interface model with IS-IS operational data.";
    container isis {
      presence "Present if an IS-IS circuit is defined for this interface.";
      description
        "IS-IS interface operational data.";

      uses interface-state;
    }
  }

  notification database-overload {
    description
      "This notification is sent when an IS-IS instance
       overload state changes.";
    uses notification-instance-hdr;

    leaf overload {
      type enumeration {
        enum "off" {
          value 0;
          description
            "Indicates IS-IS instance has left overload state";
        }
        enum "on" {
          value 1;
          description
            "Indicates IS-IS instance has entered overload state";
        }
      }
      description
        "New overload state of the IS-IS instance";
    }
  }

  notification lsp-too-large {
    description
      "This notification is sent when we attempt to propagate
       an LSP that is larger than the dataLinkBlockSize for the
       circuit.  The notification generation must be throttled
       with at least 5 seconds between successive
       notifications.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf pdu-size {
      type uint32;
      description
        "Size of the LSP PDU";
    }

    leaf lsp-id {
      type lsp-id;
      description
        "LSP ID";
    }
  }

  notification if-state-change {
    description
      "This notification is sent when an interface
       state change is detected.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf state {
      type if-state-type;
      description
        "Interface state.";
    }
  }

  notification corrupted-lsp-detected {
    description
      "This notification is sent when we find that
       an LSP that was stored in memory has become
       corrupted.";
    uses notification-instance-hdr;

    leaf lsp-id {
      type lsp-id;
      description
        "LSP ID";
    }
  }

  notification attempt-to-exceed-max-sequence {
    description
      "This notification is sent when the system
       wraps the 32-bit sequence counter of an LSP.";
    uses notification-instance-hdr;

    leaf lsp-id {
      type lsp-id;
      description
        "LSP ID";
    }
  }

  notification id-len-mismatch {
    description
      "This notification is sent when we receive a PDU
       with a different value for the System ID length.
       The notification generation must be throttled
       with at least 5 seconds between successive
       notifications.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf pdu-field-len {
      type uint8;
      description
        "Size of the ID length in the received PDU";
    }

    leaf raw-pdu {
      type binary;
      description
        "Received raw PDU.";
    }
  }

  notification max-area-addresses-mismatch {
    description
      "This notification is sent when we receive a PDU
       with a different value for the Maximum Area Addresses.
       The notification generation must be throttled
       with at least 5 seconds between successive
       notifications.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf max-area-addresses {
      type uint8;
      description
        "Received number of supported areas";
    }

    leaf raw-pdu {
      type binary;
      description
        "Received raw PDU.";
    }
  }

  notification own-lsp-purge {
    description
      "This notification is sent when the system receives
       a PDU with its own system ID and zero age.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf lsp-id {
      type lsp-id;
      description
        "LSP ID";
    }
  }

  notification sequence-number-skipped {
    description
      "This notification is sent when the system receives a
       PDU with its own system ID and different contents. The
       system has to reoriginate the LSP with a higher sequence
       number.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf lsp-id {
      type lsp-id;
      description
        "LSP ID";
    }
  }

  notification authentication-type-failure {
    description
      "This notification is sent when the system receives a
       PDU with the wrong authentication type field.
       The notification generation must be throttled
       with at least 5 seconds between successive
       notifications.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf raw-pdu {
      type binary;
      description
        "Received raw PDU.";
    }
  }

  notification authentication-failure {
    description
      "This notification is sent when the system receives
       a PDU with the wrong authentication information.
       The notification generation must be throttled with
       with at least 5 seconds between successive
       notifications.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf raw-pdu {
      type binary;
      description
        "Received raw PDU.";
    }
  }

  notification version-skew {
    description
      "This notification is sent when the system receives a
       PDU with a different protocol version number.
       The notification generation must be throttled
       with at least 5 seconds between successive
       notifications.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf protocol-version {
      type uint8;
      description
        "Protocol version received in the PDU.";
    }

    leaf raw-pdu {
      type binary;
      description
        "Received raw PDU.";
    }
  }

  notification area-mismatch {
    description
      "This notification is sent when the system receives a
       Hello PDU from an IS that does not share any area
       address. The notification generation must be throttled
       with at least 5 seconds between successive
       notifications.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf raw-pdu {
      type binary;
      description
        "Received raw PDU.";
    }
  }

  notification rejected-adjacency {
    description
      "This notification is sent when the system receives a
       Hello PDU from an IS but does not establish an adjacency
       for some reason. The notification generation must be
       throttled with at least 5 seconds between successive
       notifications.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf raw-pdu {
      type binary;
      description
        "Received raw PDU.";
    }

    leaf reason {
      type string;
      description
        "The system may provide a reason to reject the
         adjacency. If the reason is not available,
         an empty string will be returned.";
    }
  }

  notification lsp-error-detected {
    description
      "This notification is sent when the system  receives an
       LSP with a parse error. The notification generation must
       be throttled with at least 5 seconds between successive
       notifications.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf lsp-id {
      type lsp-id;
      description
        "LSP ID.";
    }

    leaf raw-pdu {
      type binary;
      description
        "Received raw PDU.";
    }

    leaf error-offset {
      type uint32;
      description
        "If the problem is a malformed TLV, the error-offset
         points to the start of the TLV. If the problem is with
         the LSP header, the error-offset points to the errant
         byte";
    }

    leaf tlv-type {
      type uint8;
      description
        "If the problem is a malformed TLV, the tlv-type is set
         to the type value of the suspicious TLV. Otherwise,
         this leaf is not present.";
    }
  }

  notification adjacency-state-change {
    description
      "This notification is sent when an IS-IS adjacency
       moves to Up state or to Down state.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf neighbor {
      type string;
      description
        "Name of the neighbor. If the name of the neighbor is
         not available, it is not returned.";
    }

    leaf neighbor-system-id {
      type system-id;
      description
        "Neighbor system-id";
    }

    leaf state {
      type adj-state-type;
      description
        "New state of the IS-IS adjacency.";
    }

    leaf reason {
      type string;
      description
        "If the adjacency is going to DOWN,  this leaf provides
         a reason for the adjacency going down. The reason is
         provided as a text. If the adjacency is going to UP, no
         reason is provided.";
    }
  }

  notification lsp-received {
    description
      "This notification is sent when an LSP is received.
       The notification generation must be throttled with at
       least 5 seconds between successive notifications.";
    uses notification-instance-hdr;

    uses notification-interface-hdr;

    leaf lsp-id {
      type lsp-id;
      description
        "LSP ID";
    }

    leaf sequence {
      type uint32;
      description
        "Sequence number of the received LSP.";
    }

    leaf received-timestamp {
      type yang:timestamp;
      description
        "Timestamp when the LSP was received.";
    }

    leaf neighbor-system-id {
      type system-id;
      description
        "Neighbor system-id of LSP sender";
    }
  }

  notification lsp-generation {
    description
      "This notification is sent when an LSP is regenerated.
       The notification generation must be throttled with at
       least 5 seconds between successive notifications.";
    uses notification-instance-hdr;

    leaf lsp-id {
      type lsp-id;
      description
        "LSP ID";
    }

    leaf sequence {
      type uint32;
      description
        "Sequence number of the received LSP.";
    }

    leaf send-timestamp {
      type yang:timestamp;
      description
        "Timestamp when our LSP was regenerated.";
    }
  }
}
