Adding upstream version 9.1.upstream/9.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2517 insertions, 0 deletions

diff --git a/yang/frr-isisd.yang b/yang/frr-isisd.yang
new file mode 100644
index 0000000..5d7c739
--- /dev/null
+++ b/yang/frr-isisd.yang
@@ -0,0 +1,2517 @@
+// 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'";
+        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'";
+        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 uint32 {
+                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.";
+    }
+  }
+}