netconfcentral logo

ietf-isis

HTML

ietf-isis@2017-11-20



  module ietf-isis {

    yang-version 1;

    namespace
      "urn:ietf:params:xml:ns:yang:ietf-isis";

    prefix isis;

    import ietf-routing {
      prefix rt;
    }
    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import ietf-interfaces {
      prefix if;
    }
    import ietf-key-chain {
      prefix key-chain;
    }
    import ietf-routing-types {
      prefix rt-types;
    }
    import iana-routing-types {
      prefix iana-rt-types;
    }

    organization "IETF ISIS Working Group";

    contact
      "WG List:  <mailto:isis-wg@ietf.org>

    Editor:    Stephane Litkowski
          <mailto:stephane.litkowski@orange.com>
        Derek Yeung
          <mailto:derek@arrcus.com>
        Acee Lindem
          <mailto:acee@cisco.com>
        Jeffrey Zhang
          <mailto:zzhang@juniper.net>
        Ladislav Lhotka
          <mailto:llhotka@nic.cz>
        Yi Yang
          <mailto:yiya@cisco.com>
        Dean Bogdanovic
          <mailto:deanb@juniper.net>
        Kiran Agrahara Sreenivasa
          <mailto:kkoushik@brocade.com>
        Yingzhen Qu
          <mailto:yiqu@cisco.com>
        Jeff Tantsura
          <mailto:jefftant.ietf@gmail.com>

    ";

    description
      "The YANG module defines a generic configuration model for
    ISIS common across all of the vendor implementations.";

    revision "2017-11-20" {
      description "Initial revision.";
      reference
        "RFC XXXX";

    }


    identity isis {
      base rt:routing-protocol;
      description
        "Identity for the ISIS routing protocol.";
    }

    identity isis-adjacency-change {
      base 
      description
        "Identity for the ISIS routing protocol
      adjacency state.";
    }

    identity clear-isis-database {
      base 
      description
        "Identity for the ISIS routing protocol
      database reset action.";
    }

    identity clear-isis-adjacency {
      base 
      description
        "Identity for the ISIS routing protocol
      adjacency reset action.";
    }

    identity lsp-log-reason {
      base 
      description
        "Base identity for an LSP change
            log reason.";
    }

    identity refresh {
      base lsp-log-reason;
      description
        "Identity used when the LSP log reason is
     a refresh LSP received.";
    }

    identity content-change {
      base lsp-log-reason;
      description
        "Identity used when the LSP log reason is
     a change in the content of the LSP.";
    }

    feature ietf-spf-delay {
      description
        "Support of IETF SPF delay algorithm.";
    }

    feature bfd {
      description
        "Support of BFD for IS-IS links.";
    }

    feature key-chain {
      description
        "Support of keychain for authentication.";
    }

    feature segment-routing {
      description
        "Support of segment-routing.";
    }

    feature node-flag {
      description
        "Support of node-flag advertisement
     as prefix attribute";
    }

    feature node-tag {
      description "Support of node tag.";
    }

    feature ldp-igp-sync {
      description "Support of RFC5443.";
    }

    feature fast-reroute {
      description "Support of IPFRR.";
    }

    feature nsr {
      description
        "Support of
        Non Stop Routing.";
    }

    feature lfa {
      description
        "Support of Loop Free Alternates.";
    }

    feature remote-lfa {
      description
        "Support of remote Loop Free Alternates.";
    }

    feature overload-max-metric {
      description
        "Support of overload by setting
       all links to max metric.";
    }

    feature prefix-tag {
      description
        "Add 32bit tag to prefixes";
    }

    feature prefix-tag64 {
      description
        "Add 64bit tag to prefixes";
    }

    feature auto-cost {
      description
        "Use an automated assignment of metrics.";
    }

    feature ipv4-router-id {
      description
        "Support of IPv4 router ID configuration under ISIS.";
    }

    feature ipv6-router-id {
      description
        "Support of IPv6 router ID configuration under ISIS.";
    }

    feature multi-topology {
      description
        "Multitopology routing support.";
    }

    feature nlpid-control {
      description
        "This feature controls the advertisement
      of support NLPID within ISIS configuration.";
    }

    feature graceful-restart {
      description
        "Graceful restart support as per RFC5306.";
    }

    feature lsp-refresh {
      description
        "Configuration of LSP refresh interval.";
    }

    feature maximum-area-addresses {
      description
        "Support of maximum-area-addresses config.";
    }

    feature admin-control {
      description
        "Control administrative state of ISIS.";
    }

    typedef instance-state-ref {
      type leafref {
        path "/rt:routing-state/rt:control-plane-protocols/rt:control-plane-protocol/rt:name";
      }
      description
        "This type is used for leaves that reference state data of
        an ISIS protocol instance.";
    }

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

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

    typedef interface-type {
      type enumeration {
        enum "broadcast" {
          value 0;
          description
            "Broadcast interface type.";
        }
        enum "point-to-point" {
          value 1;
          description
            "Point to point interface type.";
        }
      }
      description
        "This type defines the type of adjacency
     to be established on the interface.
     This is affecting the type of hello
     message that would be used.";
    }

    typedef level {
      type enumeration {
        enum "level-1" {
          value 0;
          description
            "This enum describes L1 only capability.";
        }
        enum "level-2" {
          value 1;
          description
            "This enum describes L2 only capability.";
        }
        enum "level-all" {
          value 2;
          description
            "This enum describes both levels capability.";
        }
      }
      default "level-all";
      description
        "This type defines ISIS level of an object.";
    }

    typedef adj-state-type {
      type enumeration {
        enum "Up" {
          value 0;
          description
            "This state describes that
            adjacency is established.";
        }
        enum "Down" {
          value 1;
          description
            "This state describes that
            adjacency is NOT established.";
        }
        enum "Init" {
          value 2;
          description
            "This state describes that
            adjacency is establishing.";
        }
        enum "Failed" {
          value 3;
          description
            "This state describes that
            adjacency is failed.";
        }
      }
      description
        "This type defines states of an adjacency";
    }

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

    typedef level-number {
      type uint8 {
        range "1 .. 2";
      }
      description
        "This type defines a current ISIS level.";
    }

    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 ISIS LSP ID using pattern,
      system id looks like : 0143.0438.AeF0.02-01";
    }

    typedef area-address {
      type string {
        pattern
          '[0-9A-Fa-f]{2}\.([0-9A-Fa-f]{4}\.){0,3}';
      }
      description
        "This type defines the area address format.";
    }

    typedef snpa {
      type string {
        length "0 .. 20";
      }
      description
        "This type defines Subnetwork Point
      of Attachement format.";
    }

    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 ISIS system id using pattern,
      system id looks like : 0143.0438.AeF0";
    }

    typedef wide-metric {
      type uint32 {
        range "0 .. 16777215";
      }
      description
        "This type defines wide style format
      of ISIS metric.";
    }

    typedef std-metric {
      type uint8 {
        range "0 .. 63";
      }
      description
        "This type defines old style format
      of ISIS metric.";
    }

    typedef mesh-group-state {
      type enumeration {
        enum "meshInactive" {
          value 0;
          description
            "Interface is not part of a mesh group.";
        }
        enum "meshSet" {
          value 1;
          description
            "Interface is part of a mesh group.";
        }
        enum "meshBlocked" {
          value 2;
          description
            "LSPs must not be flooded over that interface.";
        }
      }
      description
        "This type describes meshgroup state of an interface";
    }

    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-systype {
            type level;
            description
              "Type 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 usage {
            type level;
            description
              "How is the adjacency used ?
          On a p2p link this might be level 1 and 2,
          but on a LAN, the usage will be level 1
          between peers at L1 or level 2 between
          peers at L2.";
          }

          leaf hold-timer {
            type rt-types:timer-value-seconds16;
            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 lastuptime {
            type yang:timestamp;
            description
              "When the adjacency most recently entered
            state 'up', measured in hundredths of a
            second since the last reinitialization of
            the network management subsystem.
            The value is 0 if the adjacency has never
            been in state 'up'.";
          }

          leaf state {
            type adj-state-type;
            description
              "This leaf describes the state of the
           interface.";
          }
        }  // list adjacency
      }  // container adjacencies
    }  // grouping adjacency-state

    grouping fast-reroute-global-state {
      description "IPFRR states.";
      container protected-routes {
        config false;
        description
          "List of prefixes that are protected.";
        list af-stats {
          key "af prefix alternate";
          description "Per AF statistics.";
          leaf af {
            type iana-rt-types:address-family;
            description "Address-family";
          }

          leaf prefix {
            type string;
            description "Protected prefix.";
          }

          leaf alternate {
            type string;
            description
              "Alternate nexthop for the prefix.";
          }

          leaf alternate-type {
            type enumeration {
              enum "equalcost" {
                value 0;
                description
                  "ECMP alternate.";
              }
              enum "lfa" {
                value 1;
                description "LFA alternate.";
              }
              enum "remote-lfa" {
                value 2;
                description
                  "Remote LFA alternate.";
              }
              enum "tunnel" {
                value 3;
                description
                  "Tunnel based alternate
                 (like RSVP-TE or GRE).";
              }
              enum "ti-lfa" {
                value 4;
                description
                  "TI LFA alternate.";
              }
              enum "mrt" {
                value 5;
                description "MRT alternate.";
              }
              enum "other" {
                value 6;
                description
                  "Unknown alternate type.";
              }
            }
            description "Type of alternate.";
          }

          leaf best {
            type boolean;
            description
              "describes if the alternate is the best one.";
          }

          leaf non-best-reason {
            type string;
            description
              "Information field to describe why the alternate
             is not best.";
          }

          leaf protection-available {
            type bits {
              bit nodeprotect {
                position 0;
                description
                  "Node protection available.";
              }
              bit linkprotect {
                position 1;
                description
                  "Link protection available.";
              }
              bit srlgprotect {
                position 2;
                description
                  "SRLG protection available.";
              }
              bit downstreamprotect {
                position 3;
                description
                  "Downstream protection available.";
              }
              bit other {
                position 4;
                description
                  "Other protection available.";
              }
            }
            description
              "Describes protection provided by the alternate.";
          }

          leaf alternate-metric1 {
            type uint32;
            description
              "Metric from PLR to destination
              through the alternate path.";
          }

          leaf alternate-metric2 {
            type uint32;
            description
              "Metric from PLR to the alternate node";
          }

          leaf alternate-metric3 {
            type uint32;
            description
              "Metric from alternate node to the destination";
          }
        }  // list af-stats
      }  // container protected-routes

      container nonprotected-routes {
        config false;
        description
          "List of prefixes that are not protected.";
        list af-stats {
          key "af prefix";
          description "Per AF statistics.";
          leaf af {
            type iana-rt-types:address-family;
            description "Address-family";
          }

          leaf prefix {
            type string;
            description "Protected prefix.";
          }
        }  // list af-stats
      }  // container nonprotected-routes

      list protection-statistics {
        key "frr-protection-method";
        config false;
        description
          "Global protection statistics.";
        leaf frr-protection-method {
          type string;
          description
            "Protection method used.";
        }

        list af-stats {
          key "af";
          description "Per AF statistics.";
          leaf af {
            type iana-rt-types:address-family;
            description "Address-family";
          }

          leaf total-routes {
            type uint32;
            description "Total prefixes.";
          }

          leaf unprotected-routes {
            type uint32;
            description
              "Total of prefixes who are
              not protected.";
          }

          leaf protected-routes {
            type uint32;
            description
              "Total of prefixes who are
              protected.";
          }

          leaf linkprotected-routes {
            type uint32;
            description
              "Total of prefixes who are
              link protected.";
          }

          leaf nodeprotected-routes {
            type uint32;
            description
              "Total of prefixes who are
              node protected.";
          }
        }  // list af-stats
      }  // list protection-statistics
    }  // grouping fast-reroute-global-state

    grouping notification-instance-hdr {
      description
        "This group describes common instance specific
      data for notifications.";
      leaf routing-instance {
        type string;
        description
          "Describes the name of the routing-instance instance.";
      }

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

      leaf isis-level {
        type level;
        description
          "Describes the ISIS level of the instance.";
      }
    }  // grouping notification-instance-hdr

    grouping notification-interface-hdr {
      description
        "This group describes common interface specific
      data for notifications.";
      leaf interface-name {
        type string;
        description
          "Describes the name of the ISIS interface.";
      }

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

      leaf extended-circuit-id {
        type extended-circuit-id;
        description
          "Describes the extended circuit-id of the interface.";
      }
    }  // grouping notification-interface-hdr

    grouping route-content {
      description
        "This group add isis-specific route properties.";
      leaf metric {
        type uint32;
        description
          "This leaf describes ISIS metric of a route.";
      }

      leaf-list tag {
        type uint64;
        description
          "This leaf describes list of tags associated
        with the route. The leaf describes both
        32bits and 64bits tags.";
      }

      leaf route-type {
        type enumeration {
          enum "l2-up-internal" {
            value 0;
            description
              "Level 2 internal route
           and not leaked to a lower level";
          }
          enum "l1-up-internal" {
            value 1;
            description
              "Level 1 internal route
           and not leaked to a lower level";
          }
          enum "l2-up-external" {
            value 2;
            description
              "Level 2 external route
           and not leaked to a lower level";
          }
          enum "l1-up-external" {
            value 3;
            description
              "Level 1 external route
           and not leaked to a lower level";
          }
          enum "l2-down-internal" {
            value 4;
            description
              "Level 2 internal route
           and leaked to a lower level";
          }
          enum "l1-down-internal" {
            value 5;
            description
              "Level 1 internal route
           and leaked to a lower level";
          }
          enum "l2-down-external" {
            value 6;
            description
              "Level 2 external route
           and leaked to a lower level";
          }
          enum "l1-down-external" {
            value 7;
            description
              "Level 1 external route
           and leaked to a lower level";
          }
        }
        description
          "This leaf describes the type of ISIS route.";
      }
    }  // grouping route-content

    grouping admin-control {
      description
        "Grouping for admin control.";
      leaf enable {
        if-feature admin-control;
        type boolean;
        default 'true';
        description
          "Control the administrative
             state.";
      }
    }  // grouping admin-control

    grouping fast-reroute-global-cfg {
      description
        "This group defines global
     configuration of IPFRR.";
      container lfa {
        if-feature lfa;
        description
          "This container may be
        augmented with global parameters
        for LFA.
        Creating the container has no effect on
        LFA activation.";
      }  // container lfa
    }  // grouping fast-reroute-global-cfg

    grouping fast-reroute-if-cfg {
      description
        "This group defines interface
     configuration of IPFRR.";
      container lfa {
        if-feature lfa;
        description "LFA config";
        uses lfa-if-cfg;

        container level-1 {
          description "LFA level 1 config";
          uses lfa-if-cfg;
        }  // container level-1

        container level-2 {
          description "LFA level 2 config";
          uses lfa-if-cfg;
        }  // container level-2
      }  // container lfa
    }  // grouping fast-reroute-if-cfg

    grouping ietf-spf-delay-cfg {
      description
        "Grouping for IETF SPF delay configuration.";
      leaf initial-delay {
        type rt-types:timer-value-milliseconds;
        units "msec";
        description
          "Delay used while in QUIET state.";
      }

      leaf short-delay {
        type rt-types:timer-value-milliseconds;
        units "msec";
        description
          "Delay used while in SHORT_WAIT state.";
      }

      leaf long-delay {
        type rt-types:timer-value-milliseconds;
        units "msec";
        description
          "Delay used while in LONG_WAIT state.";
      }

      leaf hold-down {
        type rt-types:timer-value-milliseconds;
        units "msec";
        description
          "Timer used to consider an IGP stability period.";
      }

      leaf time-to-learn {
        type rt-types:timer-value-milliseconds;
        units "msec";
        description
          "Duration used to learn all the IGP events
         related to a single component failure.";
      }
    }  // grouping ietf-spf-delay-cfg

    grouping ietf-spf-delay-state {
      description
        "Grouping for IETF SPF delay operational states.";
      leaf current-state {
        type enumeration {
          enum "QUIET" {
            value 0;
            description "QUIET state";
          }
          enum "SHORT_WAIT" {
            value 1;
            description "SHORT_WAIT state";
          }
          enum "LONG_WAIT" {
            value 2;
            description "LONG_WAIT state";
          }
        }
        config false;
        description
          "Current state of the algorithm.";
      }

      leaf remaining-time-to-learn {
        type rt-types:timer-value-milliseconds;
        units "msec";
        config false;
        description
          "Remaining time until time-to-learn timer fires.";
      }

      leaf remaining-hold-down {
        type rt-types:timer-value-milliseconds;
        units "msec";
        config false;
        description
          "Remaining time until hold-down timer fires.";
      }

      leaf last-event-received {
        type yang:timestamp;
        config false;
        description
          "Time of last IGP event received";
      }

      leaf next-spf-time {
        type yang:timestamp;
        config false;
        description
          "Time when next SPF has been scheduled.";
      }

      leaf last-spf-time {
        type yang:timestamp;
        config false;
        description
          "Time of last SPF computation.";
      }
    }  // grouping ietf-spf-delay-state

    grouping local-rib {
      description "Local-rib grouping.";
      container local-rib {
        config false;
        description "Local-rib.";
        list route {
          key "prefix";
          description "Routes";
          leaf prefix {
            type inet:ip-prefix;
            description
              "Destination prefix.";
          }

          container next-hops {
            description
              "All next hops for the route.";
            list next-hop {
              key "next-hop";
              description
                "List of next hop for the route";
              leaf outgoing-interface {
                type if:interface-ref;
                description
                  "Name of the outgoing interface.";
              }

              leaf next-hop {
                type inet:ip-address;
                description
                  "Nexthop address.";
              }
            }  // list next-hop
          }  // container next-hops

          leaf metric {
            type uint32;
            description
              "Metric for this route.";
          }

          leaf level {
            type level-number;
            description
              "Level number for this route.";
          }

          leaf route-tag {
            type uint32;
            description
              "Route tag for this route.";
          }
        }  // list route
      }  // container local-rib
    }  // grouping local-rib

    grouping isis-node-tag-cfg {
      description "ISIS node tag config.";
      container node-tags {
        if-feature node-tag;
        description
          "Container for node tags.";
        list node-tag {
          key "tag";
          description "List of tags.";
          leaf tag {
            type uint32;
            description "Node tag value.";
          }
        }  // list node-tag
      }  // container node-tags
    }  // grouping isis-node-tag-cfg

    grouping authentication-global-cfg {
      description
        "Grouping for global auth config.";
      choice authentication-type {
        description
          "Choice of authentication.";
        case key-chain {
          if-feature key-chain;
          leaf key-chain {
            type key-chain:key-chain-ref;
            description
              "Reference to a key-chain.";
          }
        }  // case key-chain

        case password {
          leaf key {
            type string;
            description
              "This leaf describes the
               authentication key.";
          }

          leaf crypto-algorithm {
            type identityref {
              base key-chain:crypto-algorithm;
            }
            description
              "Cryptographic algorithm associated with key.";
          }
        }  // case password
      }  // choice authentication-type
    }  // grouping authentication-global-cfg

    grouping metric-type-global-cfg {
      description
        "Grouping for global metric style config.";
      leaf value {
        type enumeration {
          enum "wide-only" {
            value 0;
            description
              "Advertise new metric style only
             (RFC5305)";
          }
          enum "old-only" {
            value 1;
            description
              "Advertise old metric style only
             (RFC1195)";
          }
          enum "both" {
            value 2;
            description
              "Advertise both metric
            styles";
          }
        }
        default 'wide-only';
        description
          "This leaf describes the type of metric
         to be generated.
         Wide-only means only new metric style
         is generated,
         old-only means that only old style metric
         is generated,
         and both means that both are advertised.
         This leaf is only affecting IPv4 metrics.";
      }
    }  // grouping metric-type-global-cfg

    grouping default-metric-global-cfg {
      description
        "Grouping for global default metric config.";
      leaf value {
        type wide-metric;
        default "10";
        description "Value of the metric";
      }
    }  // grouping default-metric-global-cfg

    grouping overload-global-cfg {
      description
        "Grouping for overload bit config.";
      leaf status {
        type boolean;
        default 'false';
        description
          "This leaf defines the overload status.";
      }
    }  // grouping overload-global-cfg

    grouping overload-max-metric-global-cfg {
      description
        "Grouping for overload-max-metric config.";
      leaf timeout {
        type rt-types:timer-value-seconds16;
        units "seconds";
        description
          "This leaf defines the timeout in seconds
          of the overload condition.";
      }
    }  // grouping overload-max-metric-global-cfg

    grouping route-preference-global-cfg {
      description
        "This grouping defines how route preference is configured.";
      choice granularity {
        description
          "Choice for implementation of route preference.";
        case detail {
          leaf internal {
            type uint8;
            description
              "This leaf defines the protocol
                   preference for internal routes.";
          }

          leaf external {
            type uint8;
            description
              "This leaf defines the protocol
                   preference for external routes.";
          }
        }  // case detail
        leaf default {
          type uint8;
          description
            "This leaf defines the protocol
                   preference for all ISIS routes.";
        }
      }  // choice granularity
    }  // grouping route-preference-global-cfg

    grouping hello-authentication-cfg {
      description
        "Grouping for hello authentication.";
      choice authentication-type {
        description
          "Choice of authentication.";
        case key-chain {
          if-feature key-chain;
          leaf key-chain {
            type key-chain:key-chain-ref;
            description
              "Reference to a key-chain.";
          }
        }  // case key-chain

        case password {
          leaf key {
            type string;
            description
              "This leaf describes the
               authentication key.";
          }

          leaf crypto-algorithm {
            type identityref {
              base key-chain:crypto-algorithm;
            }
            description
              "Cryptographic algorithm associated with key.";
          }
        }  // case password
      }  // choice authentication-type
    }  // grouping hello-authentication-cfg

    grouping hello-interval-cfg {
      description
        "Interval between
     hello messages.";
      leaf value {
        type rt-types:timer-value-seconds16;
        units "seconds";
        default '10';
        description
          "This leaf defines the interval of
     hello messages.";
      }
    }  // grouping hello-interval-cfg

    grouping hello-multiplier-cfg {
      description
        "This grouping defines the number of
      hello failed to be received before
      declaring the adjacency down.";
      leaf value {
        type uint16;
        default '3';
        description
          "This leaf defines the number of
     hello failed to be received before
     declaring the adjacency down.";
      }
    }  // grouping hello-multiplier-cfg

    grouping priority-cfg {
      description
        "This grouping leaf describes the
     priority of
     the interface
     for DIS election.";
      leaf value {
        type uint8 {
          range "0 .. 127";
        }
        default '64';
        description
          "This leaf describes the priority of
     the interface
     for DIS election.";
      }
    }  // grouping priority-cfg

    grouping metric-cfg {
      description
        "Grouping for interface metric";
      leaf value {
        type wide-metric;
        default "10";
        description "Metric value.";
      }
    }  // grouping metric-cfg

    grouping lfa-if-cfg {
      description
        "Grouping for LFA
     interface configuration";
      leaf candidate-disabled {
        type boolean;
        default 'false';
        description
          "Prevent the interface to be used as backup.";
      }

      leaf enable {
        type boolean;
        default 'false';
        description
          "Activates LFA.
       This model assumes activation
       of per-prefix LFA.";
      }

      container remote-lfa {
        if-feature remote-lfa;
        description
          "remote LFA configuration.";
        leaf enable {
          type boolean;
          default 'false';
          description "Activates rLFA.";
        }
      }  // container remote-lfa
    }  // grouping lfa-if-cfg

    grouping isis-global-cfg {
      description
        "Defines the ISIS global configuration.";
      uses admin-control;

      leaf level-type {
        type level;
        default "level-all";
        description
          "This leaf describes the type of ISIS node.
           A node can be level-1-only, level-2-only
           or level-1-2.
           ";
      }

      leaf system-id {
        type system-id;
        description
          "This leaf defines the system-id of the node.";
      }

      leaf maximum-area-addresses {
        if-feature maximum-area-addresses;
        type uint8;
        default '3';
        description
          "Defines the maximum areas supported.";
      }

      leaf-list area-address {
        type area-address;
        description
          "List of areas supported by the
           protocol instance.";
      }

      container mpls {
        description
          "This container handles mpls config.";
        leaf ipv4-router-id {
          if-feature ipv4-router-id;
          type inet:ipv4-address;
          description
            "Router ID value that would be used in
             TLV 134.";
        }

        leaf ipv6-router-id {
          if-feature ipv6-router-id;
          type inet:ipv6-address;
          description
            "Router ID value that would be used in
             TLV 140.";
        }

        container ldp {
          description
            "LDP related configuration.";
          container igp-sync {
            if-feature ldp-igp-sync;
            description
              "This container may be augmented
                with global parameters for igp-ldp-sync.";
          }  // container igp-sync
        }  // container ldp
      }  // container mpls

      container auto-cost {
        if-feature auto-cost;
        description
          "This container defines the auto-cost configuration.";
        leaf reference-bandwidth {
          type uint32;
          units "bps";
          description
            "This leaf defines the bandwidth for calculating
                metric.";
        }

        leaf enable {
          type boolean;
          default 'false';
          description
            "Enable/disable auto-cost.";
        }
      }  // container auto-cost

      leaf lsp-mtu {
        type uint16;
        units "bytes";
        default '1492';
        description
          "This leaf describes the maximum size of a
            LSP PDU in bytes.";
      }

      leaf lsp-lifetime {
        type uint16 {
          range "1..65535";
        }
        units "seconds";
        description
          "This leaf describes the lifetime of the router
            LSP in seconds.";
      }

      leaf lsp-refresh {
        if-feature lsp-refresh;
        type rt-types:timer-value-seconds16;
        units "seconds";
        description
          "This leaf describes the refresh interval of the
            router LSP in seconds.";
      }

      container graceful-restart {
        if-feature graceful-restart;
        description
          "This container activates graceful restart.";
        leaf enable {
          type boolean;
          default 'false';
          description
            "Control enabling the feature.";
        }

        leaf restart-interval {
          type rt-types:timer-value-seconds16;
          units "seconds";
          description
            "Interval in seconds to attempt graceful restart prior
           to failing";
        }

        leaf helper-enable {
          type boolean;
          default 'true';
          description
            "If enabled, the local router can act as restart helper.";
        }
      }  // container graceful-restart

      container nsr {
        if-feature nsr;
        description
          "Non-Stop Routing (NSR) config state.";
        leaf enable {
          type boolean;
          default 'false';
          description "Enable/Disable NSR.";
        }
      }  // container nsr

      uses isis-node-tag-cfg;

      container authentication {
        description
          "authentication global cfg.
            It covers both LSPs and SNPs.";
        uses authentication-global-cfg;

        container level-1 {
          description "level-1 specific cfg";
          uses authentication-global-cfg;
        }  // container level-1

        container level-2 {
          description "level-2 specific cfg";
          uses authentication-global-cfg;
        }  // container level-2
      }  // container authentication

      container metric-type {
        description
          "Metric style global cfg.";
        uses metric-type-global-cfg;

        container level-1 {
          description "level-1 specific cfg";
          uses metric-type-global-cfg;
        }  // container level-1

        container level-2 {
          description "level-2 specific cfg";
          uses metric-type-global-cfg;
        }  // container level-2
      }  // container metric-type

      container default-metric {
        description
          "Default metric global cfg.";
        uses default-metric-global-cfg;

        container level-1 {
          description "level-1 specific cfg";
          uses default-metric-global-cfg;
        }  // container level-1

        container level-2 {
          description "level-2 specific cfg";
          uses default-metric-global-cfg;
        }  // container level-2
      }  // container default-metric

      container afs {
        if-feature nlpid-control;
        description
          "Container for address-families";
        list af {
          key "af";
          description
            "This list permits activation
               of new address families.";
          leaf af {
            type iana-rt-types:address-family;
            description "Address-family";
          }

          leaf enable {
            type boolean;
            description
              "Describes the activation state of the
                   AF.";
          }
        }  // list af
      }  // container afs

      container preference {
        description
          "This container defines the protocol preference.";
        uses route-preference-global-cfg;
      }  // container preference

      container overload {
        description
          "This container describes if the router is
            set to overload state.";
        uses overload-global-cfg;
      }  // container overload

      container overload-max-metric {
        if-feature overload-max-metric;
        description
          "This container describes if the router is
            set to overload state using max-metric
            advertisement.";
        uses overload-max-metric-global-cfg;
      }  // container overload-max-metric
    }  // grouping isis-global-cfg

    grouping isis-global-topologies-cfg {
      description "Per topology config.";
      container default-metric {
        description
          "Default metric per
        topology cfg.";
        uses default-metric-global-cfg;

        container level-1 {
          description "level-1 specific cfg";
          uses default-metric-global-cfg;
        }  // container level-1

        container level-2 {
          description "level-2 specific cfg";
          uses default-metric-global-cfg;
        }  // container level-2
      }  // container default-metric

      uses isis-node-tag-cfg;
    }  // grouping isis-global-topologies-cfg

    grouping isis-if-cfg {
      description
        "Grouping for interface cfg.";
      leaf level-type {
        type level;
        default "level-all";
        description
          "This leaf defines the associated ISIS
       level of the interface.";
      }

      leaf lsp-pacing-interval {
        type rt-types:timer-value-milliseconds;
        units "milliseconds";
        default '33';
        description
          "This leaf defines the interval between
        LSP transmissions in milli-seconds";
      }

      leaf lsp-retransmit-interval {
        type rt-types:timer-value-seconds16;
        units "seconds";
        description
          "This leaf defines the interval between
       retransmission of LSP";
      }

      leaf passive {
        type boolean;
        default "false";
        description
          "This leaf defines if interface is in
        passive mode (ISIS not running,
        but network is advertised).";
      }

      leaf csnp-interval {
        type rt-types:timer-value-seconds16;
        units "seconds";
        default '10';
        description
          "This leaf defines the interval of CSNP
        messages.";
      }

      container hello-padding {
        description
          "This container handles ISIS hello padding
        configuration.";
        leaf enable {
          type boolean;
          default "true";
          description
            "Status of Hello-padding activation.
          By default, the implementation shall
          pad HELLOs.";
        }
      }  // container hello-padding

      leaf mesh-group-enable {
        type mesh-group-state;
        description
          "Describes the mesh group state of
        the interface.";
      }

      leaf mesh-group {
        when
          "../mesh-group-enable = 'meshSet'" {
          description
            "Only valid when mesh-group-enable
          equals meshSet";
        }
        type uint8;
        description
          "Describes the mesh group ID of
        the interface.";
      }

      leaf interface-type {
        type interface-type;
        default "broadcast";
        description
          "This leaf defines the type of adjacency
       to be established on the interface.
       This is affecting the type of hello
       message that would be used.";
      }

      uses admin-control;

      leaf-list tag {
        if-feature prefix-tag;
        type uint32;
        description
          "This leaf defines list of tags associated
        with the interface.";
      }

      leaf-list tag64 {
        if-feature prefix-tag64;
        type uint64;
        description
          "This leaf defines list of 64bits tags
       associated with the interface.";
      }

      leaf node-flag {
        if-feature node-flag;
        type boolean;
        default 'false';
        description
          "Set prefix as a node
         representative prefix.";
      }

      container hello-authentication {
        description
          "Authentication type
       to be used in hello messages.";
        uses hello-authentication-cfg;

        container level-1 {
          description "level-1 specific cfg";
          uses hello-authentication-cfg;
        }  // container level-1

        container level-2 {
          description "level-2 specific cfg";
          uses hello-authentication-cfg;
        }  // container level-2
      }  // container hello-authentication

      container hello-interval {
        description
          "Interval between
         hello messages.";
        uses hello-interval-cfg;

        container level-1 {
          description "level-1 specific cfg";
          uses hello-interval-cfg;
        }  // container level-1

        container level-2 {
          description "level-2 specific cfg";
          uses hello-interval-cfg;
        }  // container level-2
      }  // container hello-interval

      container hello-multiplier {
        description
          "Hello multiplier
        configuration.";
        uses hello-multiplier-cfg;

        container level-1 {
          description "level-1 specific cfg";
          uses hello-multiplier-cfg;
        }  // container level-1

        container level-2 {
          description "level-2 specific cfg";
          uses hello-multiplier-cfg;
        }  // container level-2
      }  // container hello-multiplier

      container priority {
        must
          '../interface-type = "broadcast"' {
          error-message
            "Priority only applies to broadcast
             interfaces.";
          description
            "Check for broadcast interface.";
        }
        description
          "Priority for DIS election.";
        uses priority-cfg;

        container level-1 {
          description "level-1 specific cfg";
          uses priority-cfg;
        }  // container level-1

        container level-2 {
          description "level-2 specific cfg";
          uses priority-cfg;
        }  // container level-2
      }  // container priority

      container metric {
        description "Metric configuration.";
        uses metric-cfg;

        container level-1 {
          description "level-1 specific cfg";
          uses metric-cfg;
        }  // container level-1

        container level-2 {
          description "level-2 specific cfg";
          uses metric-cfg;
        }  // container level-2
      }  // container metric

      container bfd {
        if-feature bfd;
        description "BFD configuration.";
        leaf enable {
          type boolean;
          default 'false';
          description
            "
                Enables BFD on the interface
            ";
        }
      }  // container bfd

      container afs {
        if-feature nlpid-control;
        description
          "Container for address-families";
        list af {
          key "af";
          description "List of AFs.";
          leaf af {
            type iana-rt-types:address-family;
            description "Address-family";
          }
        }  // list af
      }  // container afs

      container mpls {
        description
          "Container for MPLS specific configuration
       for ISIS.";
        container ldp {
          description
            "LDP protocol related configurations.";
          leaf igp-sync {
            if-feature ldp-igp-sync;
            type boolean;
            default 'false';
            description
              "Enables IGP/LDP sync.";
          }
        }  // container ldp
      }  // container mpls
    }  // grouping isis-if-cfg

    grouping isis-if-topologies-cfg {
      description
        "ISIS interface topology cfg.";
      container metric {
        description "Metric configuration.";
        uses metric-cfg;

        container level-1 {
          description "level-1 specific cfg";
          uses metric-cfg;
        }  // container level-1

        container level-2 {
          description "level-2 specific cfg";
          uses metric-cfg;
        }  // container level-2
      }  // container metric
    }  // grouping isis-if-topologies-cfg

    grouping system-counters {
      description
        "Grouping for system counters.";
      container system-counters {
        config false;
        description
          "The container defines a list of counters
        for the IS.";
        list level {
          key "level";
          description
            "List of supported levels.";
          leaf level {
            type level-number;
            description
              "This leaf describes the ISIS level.";
          }

          leaf corrupted-lsps {
            type uint32;
            description
              "Number of corrupted in-memory LSPs detected.
           LSPs received from the wire with a bad
           checksum are silently dropped and not counted.
           LSPs received from the wire with parse errors
           are counted by lsp-errors.";
          }

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

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

          leaf database-overload {
            type uint32;
            description
              "Number of times the database has become
           overloaded.";
          }

          leaf own-lsp-purge {
            type uint32;
            description
              "Number of times a zero-aged copy of the
           system's own LSP is received from some
           other node.";
          }

          leaf manual-address-drop-from-area {
            type uint32;
            description
              "Number of times a manual address
            has been dropped from the area.";
          }

          leaf max-sequence {
            type uint32;
            description
              "Number of times the system has attempted
            to exceed the maximum sequence number.";
          }

          leaf sequence-number-skipped {
            type uint32;
            description
              "Number of times a sequence number skip has
           occured.";
          }

          leaf id-len-mismatch {
            type uint32;
            description
              "Number of times a PDU is received with
            a different value for ID field length
            from that of the receiving system.";
          }

          leaf partition-changes {
            type uint32;
            description
              "Number of partition changes detected.";
          }

          leaf lsp-errors {
            type uint32;
            description
              "Number of LSPs with errors we have
           received.";
          }

          leaf spf-runs {
            type uint32;
            description
              "Number of times we ran SPF at this level.";
          }
        }  // list level
      }  // container system-counters
    }  // grouping system-counters

    grouping event-counters {
      description
        "Grouping for event counters";
      container event-counters {
        config false;
        description
          "Provides protocol event counters.";
        leaf adjacency-changes {
          type uint32;
          description
            "The number of times an adjacency state
              change has occured 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 with
              according max area address field
              differs from that for
              this system has been received on this
              interface.";
        }

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

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

        leaf lan-dis-changes {
          type uint32;
          description
            "The number of times the DIS has changed
              on this interface at this level.
              If the interface type is point to point,
              the count is zero.";
        }
      }  // container event-counters
    }  // grouping event-counters

    grouping packet-counters {
      description
        "Grouping for packet counters.";
      container packet-counters {
        config false;
        description
          "Provides packet counters per level.";
        list level {
          key "level";
          description
            "List of supported levels.";
          leaf level {
            type level-number;
            description
              "This leaf describes the ISIS level.";
          }

          container iih {
            description
              "The number of IIH PDUs received/sent.";
            leaf in {
              type uint32;
              description "Received PDUs.";
            }

            leaf out {
              type uint32;
              description "Sent PDUs.";
            }
          }  // container iih

          container ish {
            description
              "The number of ISH PDUs received/sent.";
            leaf in {
              type uint32;
              description "Received PDUs.";
            }

            leaf out {
              type uint32;
              description "Sent PDUs.";
            }
          }  // container ish

          container esh {
            description
              "The number of ESH PDUs received/sent.";
            leaf in {
              type uint32;
              description "Received PDUs.";
            }

            leaf out {
              type uint32;
              description "Sent PDUs.";
            }
          }  // container esh

          container lsp {
            description
              "The number of LSP PDUs received/sent.";
            leaf in {
              type uint32;
              description "Received PDUs.";
            }

            leaf out {
              type uint32;
              description "Sent PDUs.";
            }
          }  // container lsp

          container psnp {
            description
              "The number of PSNP PDUs received/sent.";
            leaf in {
              type uint32;
              description "Received PDUs.";
            }

            leaf out {
              type uint32;
              description "Sent PDUs.";
            }
          }  // container psnp

          container csnp {
            description
              "The number of CSNP PDUs received/sent.";
            leaf in {
              type uint32;
              description "Received PDUs.";
            }

            leaf out {
              type uint32;
              description "Sent PDUs.";
            }
          }  // container csnp

          container unknown {
            description
              "The number of unknown PDUs received/sent.";
            leaf in {
              type uint32;
              description "Received PDUs.";
            }

            leaf out {
              type uint32;
              description "Sent PDUs.";
            }
          }  // container unknown
        }  // list level
      }  // container packet-counters
    }  // grouping packet-counters

    grouping spf-log {
      description
        "Grouping for spf-log events.";
      container spf-log {
        config false;
        description
          "This container lists the SPF computation events.";
        list event {
          key "id";
          description
            "List of computation events.
         It is used as a wrapping buffer.";
          leaf id {
            type uint32;
            description
              "This leaf defines the event identifier.
            This is a purely internal value.";
          }

          leaf spf-type {
            type enumeration {
              enum "full" {
                value 0;
                description
                  "Computation done is a Full SPF.";
              }
              enum "route-only" {
                value 1;
                description
                  "Computation done is a
                reachability computation
                only.";
              }
            }
            description
              "This leaf describes the type of computation
           used.";
          }

          leaf level {
            type level-number;
            description
              "This leaf describes the level affected by the
           the computation.";
          }

          leaf schedule-timestamp {
            type yang:timestamp;
            description
              "This leaf describes the timestamp
            when the computation was scheduled.";
          }

          leaf start-timestamp {
            type yang:timestamp;
            description
              "This leaf describes the timestamp
            when the computation was started.";
          }

          leaf end-timestamp {
            type yang:timestamp;
            description
              "This leaf describes the timestamp
            when the computation was ended.";
          }

          list trigger-lsp {
            key "lsp";
            description
              "This leaf describes list of LSPs
            that triggered the computation.";
            leaf lsp {
              type lsp-id;
              description
                "This leaf describes the LSPID
              of the LSP.";
            }

            leaf sequence {
              type uint32;
              description
                "This leaf describes the sequence
              number of the LSP.";
            }
          }  // list trigger-lsp
        }  // list event
      }  // container spf-log
    }  // grouping spf-log

    grouping lsp-log {
      description "Grouping for LSP log.";
      container lsp-log {
        config false;
        description
          "This container lists the LSP reception events.
       Local LSP modification are also contained in the
       list.";
        list event {
          key "id";
          description
            "List of LSP events.
         It is used as a wrapping buffer.";
          leaf id {
            type uint32;
            description
              "This leaf defines the event identifier.
            This is a purely internal value.";
          }

          leaf level {
            type level-number;
            description
              "This leaf describes the level affected by the
           the computation.";
          }

          container lsp {
            description
              "This container describes the received LSP
           , in case of local LSP update the local
           LSP ID is referenced.";
            leaf lsp {
              type lsp-id;
              description
                "This leaf describes the LSPID
              of the LSP.";
            }

            leaf sequence {
              type uint32;
              description
                "This leaf describes the sequence
              number of the LSP.";
            }
          }  // container lsp

          leaf received-timestamp {
            type yang:timestamp;
            description
              "This leaf describes the timestamp
           when the LSP was received. In case of
           local LSP update, the timestamp refers
           to the local LSP update time.";
          }

          leaf change {
            type identityref {
              base lsp-log-reason;
            }
            description
              "This leaf describes the type of change
           in the LSP.";
          }
        }  // list event
      }  // container lsp-log
    }  // grouping lsp-log

    grouping hostname-db {
      description
        "Grouping for hostname to systemid mapping database.";
      container hostnames {
        config false;
        description
          "This container describes the list
       of binding between system-id and
       hostnames.";
        list hostname {
          key "system-id";
          description
            "List of system-id/hostname associations";
          leaf system-id {
            type system-id;
            description
              "This leaf describes the system-id
           associated with the hostname.";
          }

          leaf hostname {
            type string;
            description
              "This leaf describes the hostname
            associated with the system ID.";
          }
        }  // list hostname
      }  // container hostnames
    }  // grouping hostname-db

    grouping prefix-reachability-attributes {
      description
        "This group defines extended reachability attributes of an
      IPv4 or IPv6 prefix.";
      leaf external-prefix-flag {
        type boolean;
        description "External prefix flag.";
      }

      leaf readvertisement-flag {
        type boolean;
        description "Readvertisement flag.";
      }

      leaf node-flag {
        type boolean;
        description "Node flag.";
      }
    }  // grouping prefix-reachability-attributes

    grouping prefix-ipv4-source-router-id {
      description
        "This group defines the IPv4 source router ID of
     a prefix advertisement.";
      leaf ipv4-source-router-id {
        type inet:ipv4-address;
        description
          "IPv4 Source router ID address.";
      }
    }  // grouping prefix-ipv4-source-router-id

    grouping prefix-ipv6-source-router-id {
      description
        "This group defines the IPv6 source router ID of
     a prefix advertisement.";
      leaf ipv6-source-router-id {
        type inet:ipv6-address;
        description
          "IPv6 Source router ID address.";
      }
    }  // grouping prefix-ipv6-source-router-id

    grouping prefix-attributes-extension {
      description
        "Prefix extended attributes.";
      uses prefix-reachability-attributes;

      uses prefix-ipv4-source-router-id;

      uses prefix-ipv6-source-router-id;
    }  // grouping prefix-attributes-extension

    grouping prefix-ipv4-std {
      description
        "This group defines attributes of an
      IPv4 standard prefix.";
      leaf up-down {
        type boolean;
        description
          "This leaf expresses the value of up/down bit.";
      }

      leaf i-e {
        type boolean;
        description
          "This leaf expresses the value of I/E bit.";
      }

      leaf ip-prefix {
        type inet:ipv4-address;
        description
          "This leaf describes the IPv4 prefix";
      }

      leaf prefix-len {
        type uint8;
        description
          "This leaf describes the IPv4 prefix len in bits";
      }

      leaf default-metric {
        type std-metric;
        description
          "This leaf describes the ISIS default metric value";
      }

      container delay-metric {
        description
          "This container defines the ISIS delay metric.";
        leaf metric {
          type std-metric;
          description
            "This leaf describes the ISIS delay metric value";
        }

        leaf supported {
          type boolean;
          default "false";
          description
            "This leaf describes if the metric is supported.";
        }
      }  // container delay-metric

      container expense-metric {
        description
          "This container defines the ISIS expense metric.";
        leaf metric {
          type std-metric;
          description
            "This leaf describes the ISIS expense metric value";
        }

        leaf supported {
          type boolean;
          default "false";
          description
            "This leaf describes if the metric is supported.";
        }
      }  // container expense-metric

      container error-metric {
        description
          "This container defines the ISIS error metric.";
        leaf metric {
          type std-metric;
          description
            "This leaf describes the ISIS error metric value";
        }

        leaf supported {
          type boolean;
          default "false";
          description
            "This leaf describes if the metric is supported.";
        }
      }  // container error-metric
    }  // grouping prefix-ipv4-std

    grouping prefix-ipv4-extended {
      description
        "This group defines attributes of an
      IPv4 extended prefix.";
      leaf up-down {
        type boolean;
        description
          "This leaf expresses the value of up/down bit.";
      }

      leaf ip-prefix {
        type inet:ipv4-address;
        description
          "This leaf describes the IPv4 prefix";
      }

      leaf prefix-len {
        type uint8;
        description
          "This leaf describes the IPv4 prefix len in bits";
      }

      leaf metric {
        type wide-metric;
        description
          "This leaf describes the ISIS metric value";
      }

      leaf-list tag {
        type uint32;
        description
          "This leaf describes a list of tags associated with
       the prefix.";
      }

      leaf-list tag64 {
        type uint64;
        description
          "This leaf describes a list of 64-bit tags associated with
       the prefix.";
      }

      uses prefix-attributes-extension;
    }  // grouping prefix-ipv4-extended

    grouping prefix-ipv6-extended {
      description
        "This group defines attributes of an
      IPv6 prefix.";
      leaf up-down {
        type boolean;
        description
          "This leaf expresses the value of up/down bit.";
      }

      leaf ip-prefix {
        type inet:ipv6-address;
        description
          "This leaf describes the IPv6 prefix";
      }

      leaf prefix-len {
        type uint8;
        description
          "This leaf describes the IPv4 prefix len in bits";
      }

      leaf metric {
        type wide-metric;
        description
          "This leaf describes the ISIS metric value";
      }

      leaf-list tag {
        type uint32;
        description
          "This leaf describes a list of tags associated with
       the prefix.";
      }

      leaf-list tag64 {
        type uint64;
        description
          "This leaf describes a list of 64-bit tags associated with
       the prefix.";
      }

      uses prefix-attributes-extension;
    }  // grouping prefix-ipv6-extended

    grouping neighbor-extended {
      description
        "This group defines attributes of an
      ISIS extended neighbor.";
      leaf neighbor-id {
        type system-id;
        description
          "This leaf describes the system-id of the neighbor.";
      }

      leaf metric {
        type wide-metric;
        description
          "This leaf describes the ISIS metric value";
      }
    }  // grouping neighbor-extended

    grouping neighbor {
      description
        "This group defines attributes of an
      ISIS standard neighbor.";
      leaf neighbor-id {
        type system-id;
        description
          "This leaf describes the system-id of the neighbor.";
      }

      leaf i-e {
        type boolean;
        description
          "This leaf expresses the value of I/E bit.";
      }

      leaf default-metric {
        type std-metric;
        description
          "This leaf describes the ISIS default metric value";
      }

      container delay-metric {
        description
          "This container defines the ISIS delay metric.";
        leaf metric {
          type std-metric;
          description
            "This leaf describes the ISIS delay metric value";
        }

        leaf supported {
          type boolean;
          default "false";
          description
            "This leaf describes if the metric is supported.";
        }
      }  // container delay-metric

      container expense-metric {
        description
          "This container defines the ISIS expense metric.";
        leaf metric {
          type std-metric;
          description
            "This leaf describes the ISIS delay expense value";
        }

        leaf supported {
          type boolean;
          default "false";
          description
            "This leaf describes if the metric is supported.";
        }
      }  // container expense-metric

      container error-metric {
        description
          "This container defines the ISIS error metric.";
        leaf metric {
          type std-metric;
          description
            "This leaf describes the ISIS error metric value";
        }

        leaf supported {
          type boolean;
          default "false";
          description
            "This leaf describes if the metric is supported.";
        }
      }  // container error-metric
    }  // grouping neighbor

    grouping lsp-entry {
      description
        "This group defines attributes of an
      ISIS LSP database entry.";
      leaf decoded-completed {
        type boolean;
        description
          "The IS-IS body is fully decoded.";
      }

      leaf raw-data {
        type yang:hex-string;
        description
          "The complete LSP in network byte
         order hexadecimal as received or originated.";
      }

      leaf lsp-id {
        type lsp-id;
        description
          "This leaf describes the LSP ID of the LSP.";
      }

      leaf checksum {
        type uint16;
        description
          "This leaf describes the checksum of the LSP.";
      }

      leaf remaining-lifetime {
        type uint16;
        units "seconds";
        description
          "This leaf describes the remaining lifetime
        in seconds before the LSP expiration.";
      }

      leaf sequence {
        type uint32;
        description
          "This leaf describes the sequence number of the LSP.";
      }

      leaf attributes {
        type bits {
          bit PARTITIONNED {
            position 0;
            description
              "If set, the originator supports partition
            repair.";
          }
          bit ATTACHED-ERROR {
            position 1;
            description
              "If set, the originator is attached to
            another area using the referred metric.";
          }
          bit ATTACHED-EXPENSE {
            position 2;
            description
              "If set, the originator is attached to
            another area using the referred metric.";
          }
          bit ATTACHED-DELAY {
            position 3;
            description
              "If set, the originator is attached to
            another area using the referred metric.";
          }
          bit ATTACHED-DEFAULT {
            position 4;
            description
              "If set, the originator is attached to
            another area using the referred metric.";
          }
          bit OVERLOAD {
            position 5;
            description
              "If set, the originator is overloaded,
            and must be avoided in path calculation.";
          }
        }
        description
          "This leaf describes attributes of the LSP.";
      }

      leaf-list ipv4-addresses {
        type inet:ipv4-address;
        description
          "This leaf describes the IPv4 addresses of the node.
        ISIS reference is TLV 132.";
      }

      leaf-list ipv6-addresses {
        type inet:ipv6-address;
        description
          "This leaf describes the IPv6 interface
       addresses of the node.
       ISIS reference is TLV 232.";
      }

      leaf ipv4-te-routerid {
        type inet:ipv4-address;
        description
          "This leaf describes the IPv4 Traffic Engineering
        router ID of the node.
        ISIS reference is TLV 134.";
      }

      leaf ipv6-te-routerid {
        type inet:ipv6-address;
        description
          "This leaf describes the IPv6 Traffic Engineering
        router ID of the node.
        ISIS reference is TLV 140.";
      }

      leaf-list protocol-supported {
        type uint8;
        description
          "This leaf describes the list of
       supported protocols.
       ISIS reference is TLV 129.";
      }

      leaf dynamic-hostname {
        type string;
        description
          "This leaf describes the name of the node.
       ISIS reference is TLV 137.";
      }

      container authentication {
        description
          "This container describes authentication
      information of the node. ISIS reference is TLV 10.";
        leaf authentication-type {
          type string;
          description
            "This leaf describes the authentication type
          to be used.";
        }

        leaf authentication-key {
          type string;
          description
            "This leaf describes the authentication key
          to be used. For security reason, the
          authentication key MUST NOT be presented
          in plaintext format. Authors recommends
          to use MD5 hash to present the authentication-key.";
        }
      }  // container authentication

      container mt-entries {
        description
          "This container describes the topology supported.
       ISIS reference is TLV 229.";
        list topology {
          description
            "List of topologies supported.";
          leaf MT-ID {
            type uint16 {
              range "0 .. 4095";
            }
            description
              "This leaf defines the identifier
            of a topology.";
          }

          leaf attributes {
            type bits {
              bit OVERLOAD {
                position 0;
                description
                  "If set, the originator is overloaded,
                and must be avoided in path
                calculation.";
              }
              bit ATTACHED {
                position 1;
                description
                  "If set, the originator is attached to
                another area using the referred metric.";
              }
            }
            description
              "This leaf describes attributes of the LSP
            for the associated topology.";
          }
        }  // list topology
      }  // container mt-entries

      list router-capabilities {
        description
          "This container describes the capabilities of the node.
       This container may be extended with detailed
       information.
       ISIS reference is TLV 242.";
        leaf flags {
          type bits {
            bit flooding {
              position 0;
              description
                "If the S bit is set(1),
             the IS-IS Router CAPABILITY TLV
            MUST be flooded across the entire routing domain.
            If the S bit is
            not set(0), the TLV MUST NOT be leaked between levels.
            This bit MUST NOT be altered during the TLV leaking.";
            }
            bit down {
              position 1;
              description
                "When the IS-IS Router CAPABILITY TLV is
            leaked from level-2 to level-1, the D bit
            MUST be set.  Otherwise, this bit MUST
            be clear.  IS-IS Router capability TLVs
            with the D bit set MUST NOT
            be leaked from level-1 to level-2.
            This is to prevent TLV looping.
            ";
            }
          }
          description
            "Flags associated with router capability.";
        }

        container node-tags {
          if-feature node-tag;
          description
            "Container for node tags.";
          list node-tag {
            description "List of tags.";
            leaf tag {
              type uint32;
              description "Node tag value.";
            }
          }  // list node-tag
        }  // container node-tags

        leaf binary {
          type binary;
          description
            "This leaf describes the capability of the node.
         Format is binary according to the protocol encoding.";
        }
      }  // list router-capabilities

      container is-neighbor {
        description
          "This leaf describes list of ISIS neighbors.
       ISIS reference is TLV 2.";
        list neighbor {
          description "List of neighbors.";
          uses neighbor;
        }  // list neighbor
      }  // container is-neighbor

      container extended-is-neighbor {
        description
          "This container describes list of ISIS extended
       neighbors.
       ISIS reference is TLV 22.";
        list neighbor {
          description "List of neighbors.";
          uses neighbor-extended;
        }  // list neighbor
      }  // container extended-is-neighbor

      container ipv4-internal-reachability {
        description
          "This container describes list of IPv4 internal
       reachability information.
       ISIS reference is TLV 128.";
        list prefixes {
          description "List of prefixes.";
          uses prefix-ipv4-std;
        }  // list prefixes
      }  // container ipv4-internal-reachability

      container ipv4-external-reachability {
        description
          "This container describes list of IPv4 external
       reachability information.
       ISIS reference is TLV 130.";
        list prefixes {
          description "List of prefixes.";
          uses prefix-ipv4-std;
        }  // list prefixes
      }  // container ipv4-external-reachability

      container extended-ipv4-reachability {
        description
          "This container describes list of IPv4 extended
       reachability information.
       ISIS reference is TLV 135.";
        list prefixes {
          description "List of prefixes.";
          uses prefix-ipv4-extended;
        }  // list prefixes
      }  // container extended-ipv4-reachability

      container mt-is-neighbor {
        description
          "This container describes list of ISIS multi-topology
        neighbors.
        ISIS reference is TLV 223.";
        list neighbor {
          description "List of neighbors.";
          leaf MT-ID {
            type uint16 {
              range "0 .. 4095";
            }
            description
              "This leaf defines the identifier
            of a topology.";
          }

          uses neighbor-extended;
        }  // list neighbor
      }  // container mt-is-neighbor

      container mt-extended-ipv4-reachability {
        description
          "This container describes list of IPv4
       reachability information in multi-topology
       environment.
       ISIS reference is TLV 235.";
        list prefixes {
          description "List of prefixes.";
          leaf MT-ID {
            type uint16 {
              range "0 .. 4095";
            }
            description
              "This leaf defines the identifier
            of a topology.";
          }

          uses prefix-ipv4-extended;
        }  // list prefixes
      }  // container mt-extended-ipv4-reachability

      container mt-ipv6-reachability {
        description
          "This container describes list of IPv6
       reachability information in multi-topology
       environment.
       ISIS reference is TLV 237.";
        list prefixes {
          description "List of prefixes.";
          leaf MT-ID {
            type uint16 {
              range "0 .. 4095";
            }
            description
              "This leaf defines the identifier
            of a topology.";
          }

          uses prefix-ipv6-extended;
        }  // list prefixes
      }  // container mt-ipv6-reachability

      container ipv6-reachability {
        description
          "This container describes list of IPv6
       reachability information.
       ISIS reference is TLV 236.";
        list prefixes {
          description "List of prefixes.";
          uses prefix-ipv6-extended;
        }  // list prefixes
      }  // container ipv6-reachability
    }  // grouping lsp-entry

    grouping lsdb {
      description
        "Grouping for LSDB description.";
      container database {
        config false;
        description
          "This container describes ISIS Link State
        databases.";
        list level-db {
          key "level";
          description
            "This container describes the list of LSPs
         in the level x database.";
          leaf level {
            type level-number;
            description
              "Current level number";
          }

          list lsp {
            key "lsp-id";
            description
              "List of LSPs in LSDB.";
            uses lsp-entry;
          }  // list lsp
        }  // list level-db
      }  // container database
    }  // grouping lsdb

    augment /rt:routing/rt:ribs/rt:rib/rt:routes/rt:route {
      when
        "rt:source-protocol = 'isis:isis'" {
        description
          "ISIS-specific route attributes.";
      }
      description
        "This augments route object in RIB with ISIS-specific
      attributes.";
      uses route-content;
    }

    augment /if:interfaces/if:interface {
      description "ISO interface config.";
      leaf clns-mtu {
        type uint16;
        description
          "Defines CLNS MTU of the interface.";
      }
    }

    augment /rt:routing/rt:control-plane-protocols/rt:control-plane-protocol {
      when "rt:type = 'isis:isis'" {
        description
          "This augment is only valid when routing protocol
        instance type is isis.";
      }
      description
        "This augments a routing protocol instance with ISIS
      specific parameters.";
      container isis {
        must "count(area-address) > 0" {
          error-message
            "At least one area-address
          must be configured.";
          description
            "Enforce configuration of at least one area.";
        }
        description
          "This container defines ISIS specific configuration
         objects.";
        uses isis-global-cfg;

        container fast-reroute {
          if-feature fast-reroute;
          description "IPFRR.";
          uses fast-reroute-global-cfg;

          uses fast-reroute-global-state;
        }  // container fast-reroute

        container spf-control {
          description
            "Container for all SPF computation related
             operations.";
          container ietf-spf-delay {
            if-feature ietf-spf-delay;
            description
              "IETF spf delay algorithm configuration.";
            uses ietf-spf-delay-cfg;

            uses ietf-spf-delay-state;
          }  // container ietf-spf-delay
        }  // container spf-control

        container topologies {
          if-feature multi-topology;
          description
            "Container for multi-topology";
          list topology {
            key "name";
            description "List of topologies";
            leaf enable {
              type boolean;
              description
                "Control enabling of topologies";
            }

            leaf name {
              type leafref {
                path
                  "../../../../../../rt:ribs/rt:rib/rt:name";
              }
              description "RIB";
            }

            uses isis-global-topologies-cfg;
          }  // list topology
        }  // container topologies

        container interfaces {
          description
            "This container defines ISIS interface specific
           configuration objects.";
          list interface {
            key "name";
            description
              "List of ISIS interfaces.";
            leaf name {
              type if:interface-ref;
              description
                "Reference to the interface within
                the routing-instance.";
            }

            uses isis-if-cfg;

            container fast-reroute {
              if-feature fast-reroute;
              description "IPFRR.";
              uses fast-reroute-if-cfg;
            }  // container fast-reroute

            container topologies {
              if-feature multi-topology;
              description
                "Container for multi-topology";
              list topology {
                key "name";
                description
                  "List of topologies.";
                leaf name {
                  type leafref {
                    path
                      "../../../../../../../../"
                        + "rt:ribs/rt:rib/rt:name";
                  }
                  description "Name of RIB.";
                }

                uses isis-if-topologies-cfg;
              }  // list topology
            }  // container topologies

            uses adjacency-state;

            uses event-counters;

            uses packet-counters;
          }  // list interface
        }  // container interfaces

        uses spf-log;

        uses lsp-log;

        uses hostname-db;

        uses lsdb;

        uses local-rib;

        uses system-counters;
      }  // container isis
    }

    rpc clear-adjacency {
      description
        "This RPC request clears a particular
      set of ISIS adjacencies. If the operation
      fails for ISIS internal reason, then
      error-tag and error-app-tag should be set
      to a meaningful value.";
      input {
        leaf routing-protocol-instance-name {
          type instance-state-ref;
          mandatory true;
          description
            "Name of the ISIS protocol instance whose ISIS
          information is being queried.

          If the ISIS instance with name equal to the
          value of this parameter doesn't exist, then this
          operation SHALL fail with error-tag 'data-missing'
          and error-app-tag
          'routing-protocol-instance-not-found'.";
        }

        leaf level {
          type level;
          description
            "ISIS level of the adjacency to be cleared.
         If ISIS level is level-1-2, both level 1 and level 2
         adjacencies would be cleared.

         If the value provided is different from the one
         authorized in the enum type, then this
          operation SHALL fail with error-tag 'data-missing'
          and error-app-tag
          'bad-isis-level'.
         ";
        }

        leaf interface {
          type string;
          description
            "Name of the ISIS interface.

          If the ISIS interface with name equal to the
          value of this parameter doesn't exist, then this
          operation SHALL fail with error-tag 'data-missing'
          and error-app-tag
          'isis-interface-not-found'.";
        }
      }
    }  // rpc clear-adjacency

    rpc clear-database {
      description
        "This RPC request clears a particular
      ISIS database. If the operation
      fails for ISIS internal reason, then
      error-tag and error-app-tag should be set
      to a meaningful value.";
      input {
        leaf routing-protocol-instance-name {
          type instance-state-ref;
          mandatory true;
          description
            "Name of the ISIS protocol instance whose ISIS
          information is being queried.

          If the ISIS instance with name equal to the
          value of this parameter doesn't exist, then this
          operation SHALL fail with error-tag 'data-missing'
          and error-app-tag
          'routing-protocol-instance-not-found'.";
        }

        leaf level {
          type level;
          description
            "ISIS level of the adjacency to be cleared.
         If ISIS level is level-1-2, both level 1 and level 2
         adjacencies would be cleared.

         If the value provided is different from the one
         authorized in the enum type, then this
          operation SHALL fail with error-tag 'data-missing'
          and error-app-tag
          'bad-isis-level'.
         ";
        }
      }
    }  // rpc clear-database

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

      leaf overload {
        type enumeration {
          enum "off" {
            value 0;
            description
              "The system has left overload condition.";
          }
          enum "on" {
            value 1;
            description
              "The system is in overload condition.";
          }
        }
        description
          "Describes the new overload state of the instance.";
      }
    }  // notification database-overload

    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 a 5 second gap.
       ";
      uses notification-instance-hdr;

      uses notification-interface-hdr;

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

      leaf lsp-id {
        type lsp-id;
        description "LSP ID.";
      }
    }  // notification lsp-too-large

    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 if-state-change

    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 corrupted-lsp-detected

    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 attempt-to-exceed-max-sequence

    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 a 5 second gap.
       ";
      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 id-len-mismatch

    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 a 5 second gap.
       ";
      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 max-area-addresses-mismatch

    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 own-lsp-purge

    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 reissue
      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 sequence-number-skipped

    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 a 5 second gap.
       ";
      uses notification-instance-hdr;

      uses notification-interface-hdr;

      leaf raw-pdu {
        type binary;
        description "Received raw PDU.";
      }
    }  // notification authentication-type-failure

    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
      at least a 5 second gap.
       ";
      uses notification-instance-hdr;

      uses notification-interface-hdr;

      leaf raw-pdu {
        type binary;
        description "Received raw PDU.";
      }
    }  // notification authentication-failure

    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
       a 5 second gap.
       ";
      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 version-skew

    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
       a 5 second gap.
       ";
      uses notification-instance-hdr;

      uses notification-interface-hdr;

      leaf raw-pdu {
        type binary;
        description "Received raw PDU.";
      }
    }  // notification area-mismatch

    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
       a 5 second gap.
       ";
      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,
        the system use an empty string.";
      }
    }  // notification rejected-adjacency

    notification protocols-supported-mismatch {
      description
        "This notification is sent when the system
      receives a non pseudonode LSP that has no matching
      protocol supported.
      The notification generation must be throttled with at least
       a 5 second gap.
       ";
      uses notification-instance-hdr;

      uses notification-interface-hdr;

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

      leaf-list protocols {
        type uint8;
        description
          "The list of protocols supported by the
        remote system.";
      }
    }  // notification protocols-supported-mismatch

    notification lsp-error-detected {
      description
        "This notification is sent when the system
      receives a  LSP with a parse error.
      The notification generation must be throttled with at least
       a 5 second gap.
       ";
      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 suspicious 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 lsp-error-detected

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

      uses notification-interface-hdr;

      leaf neighbor {
        type string;
        description
          "Describes the name of the neighbor. If the
       name of the neighbor is not available, the
       field would be empty.";
      }

      leaf neighbor-system-id {
        type system-id;
        description
          "Describes the system-id of the neighbor.";
      }

      leaf state {
        type adj-state-type;
        description
          "This leaf describes the new state of the
        ISIS 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 adjacency-state-change

    notification lsp-received {
      description
        "This notification is sent when a LSP
      is received.
      The notification generation must be throttled with at least
       a 5 second gap. ";
      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
          "This leaf describes the timestamp
       when the LSP was received. ";
      }

      leaf neighbor-system-id {
        type system-id;
        description
          "Describes the system-id of the neighbor
       that sent the LSP.";
      }
    }  // notification lsp-received

    notification lsp-generation {
      description
        "This notification is sent when a LSP
      is regenerated.
      The notification generation must be throttled with at least
       a 5 second gap. ";
      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
          "This leaf describes the timestamp
       when our LSP was regenerated. ";
      }
    }  // notification lsp-generation
  }  // module ietf-isis

Summary

  
  
Organization IETF ISIS Working Group
  
Module ietf-isis
Version 2017-11-20
File ietf-isis@2017-11-20.yang
  
Prefix isis
Namespace urn:ietf:params:xml:ns:yang:ietf-isis
  
Cooked /cookedmodules/ietf-isis/2017-11-20
YANG /src/ietf-isis@2017-11-20.yang
XSD /xsd/ietf-isis@2017-11-20.xsd
  
Abstract The YANG module defines a generic configuration model for ISIS common across all of the vendor implementations.
  
Contact
WG List:  <mailto:isis-wg@ietf.org>

Editor:    Stephane Litkowski
     <mailto:stephane.litkowski@orange.com>
   Derek Yeung
     <mailto:derek@arrcus.com>
   Acee Lindem
     <mailto:acee@cisco.com>
   Jeffrey Zhang
     <mailto:zzhang@juniper.net>
   Ladislav Lhotka
     <mailto:llhotka@nic.cz>
   Yi Yang
     <mailto:yiya@cisco.com>
   Dean Bogdanovic
     <mailto:deanb@juniper.net>
   Kiran Agrahara Sreenivasa
     <mailto:kkoushik@brocade.com>
   Yingzhen Qu
     <mailto:yiqu@cisco.com>
   Jeff Tantsura
     <mailto:jefftant.ietf@gmail.com>

Description

 
The YANG module defines a generic configuration model for
ISIS common across all of the vendor implementations.

Typedefs

Typedef Base type Abstract
adj-state-type enumeration This type defines states of an adjacency
area-address string This type defines the area address format.
circuit-id uint8 This type defines the circuit ID associated with an interface.
extended-circuit-id uint32 This type defines the extended circuit ID associated with an interface.
if-state-type enumeration This type defines states of an interface
instance-state-ref leafref This type is used for leaves that reference state data of an ISIS protocol instance.
interface-type enumeration This type defines the type of adjacency to be established on the interface. This is affecting the type of hello message that would be used.
level enumeration This type defines ISIS level of an object.
level-number uint8 This type defines a current ISIS level.
lsp-id string This type defines ISIS LSP ID using pattern, system id looks like : 0143.0438.AeF0.02-01
mesh-group-state enumeration This type describes meshgroup state of an interface
snpa string This type defines Subnetwork Point of Attachement format.
std-metric uint8 This type defines old style format of ISIS metric.
system-id string This type defines ISIS system id using pattern, system id looks like : 0143.0438.AeF0
wide-metric uint32 This type defines wide style format of ISIS metric.

Groupings

Grouping Objects Abstract
adjacency-state adjacencies Adjacency state
admin-control enable Grouping for admin control.
authentication-global-cfg authentication-type Grouping for global auth config.
default-metric-global-cfg value Grouping for global default metric config.
event-counters event-counters Grouping for event counters
fast-reroute-global-cfg lfa This group defines global configuration of IPFRR.
fast-reroute-global-state protected-routes nonprotected-routes protection-statistics IPFRR states.
fast-reroute-if-cfg lfa This group defines interface configuration of IPFRR.
hello-authentication-cfg authentication-type Grouping for hello authentication.
hello-interval-cfg value Interval between hello messages.
hello-multiplier-cfg value This grouping defines the number of hello failed to be received before declaring the adjacency down.
hostname-db hostnames Grouping for hostname to systemid mapping database.
ietf-spf-delay-cfg initial-delay short-delay long-delay hold-down time-to-learn Grouping for IETF SPF delay configuration.
ietf-spf-delay-state current-state remaining-time-to-learn remaining-hold-down last-event-received next-spf-time last-spf-time Grouping for IETF SPF delay operational states.
isis-global-cfg enablelevel-type system-id maximum-area-addresses area-address mpls auto-cost lsp-mtu lsp-lifetime lsp-refresh graceful-restart nsr node-tagsauthentication metric-type default-metric afs preference overload overload-max-metric Defines the ISIS global configuration.
isis-global-topologies-cfg default-metric node-tags Per topology config.
isis-if-cfg level-type lsp-pacing-interval lsp-retransmit-interval passive csnp-interval hello-padding mesh-group-enable mesh-group interface-type enabletag tag64 node-flag hello-authentication hello-interval hello-multiplier priority metric bfd afs mpls Grouping for interface cfg.
isis-if-topologies-cfg metric ISIS interface topology cfg.
isis-node-tag-cfg node-tags ISIS node tag config.
lfa-if-cfg candidate-disabled enable remote-lfa Grouping for LFA interface configuration
local-rib local-rib Local-rib grouping.
lsdb database Grouping for LSDB description.
lsp-entry decoded-completed raw-data lsp-id checksum remaining-lifetime sequence attributes ipv4-addresses ipv6-addresses ipv4-te-routerid ipv6-te-routerid protocol-supported dynamic-hostname authentication mt-entries router-capabilities is-neighbor extended-is-neighbor ipv4-internal-reachability ipv4-external-reachability extended-ipv4-reachability mt-is-neighbor mt-extended-ipv4-reachability mt-ipv6-reachability ipv6-reachability This group defines attributes of an ISIS LSP database entry.
lsp-log lsp-log Grouping for LSP log.
metric-cfg value Grouping for interface metric
metric-type-global-cfg value Grouping for global metric style config.
neighbor neighbor-id i-e default-metric delay-metric expense-metric error-metric This group defines attributes of an ISIS standard neighbor.
neighbor-extended neighbor-id metric This group defines attributes of an ISIS extended neighbor.
notification-instance-hdr routing-instance routing-protocol-name isis-level This group describes common instance specific data for notifications.
notification-interface-hdr interface-name interface-level extended-circuit-id This group describes common interface specific data for notifications.
overload-global-cfg status Grouping for overload bit config.
overload-max-metric-global-cfg timeout Grouping for overload-max-metric config.
packet-counters packet-counters Grouping for packet counters.
prefix-attributes-extension external-prefix-flag readvertisement-flag node-flagipv4-source-router-idipv6-source-router-id Prefix extended attributes.
prefix-ipv4-extended up-down ip-prefix prefix-len metric tag tag64 external-prefix-flag readvertisement-flag node-flag ipv4-source-router-id ipv6-source-router-id This group defines attributes of an IPv4 extended prefix.
prefix-ipv4-source-router-id ipv4-source-router-id This group defines the IPv4 source router ID of a prefix advertisement.
prefix-ipv4-std up-down i-e ip-prefix prefix-len default-metric delay-metric expense-metric error-metric This group defines attributes of an IPv4 standard prefix.
prefix-ipv6-extended up-down ip-prefix prefix-len metric tag tag64 external-prefix-flag readvertisement-flag node-flag ipv4-source-router-id ipv6-source-router-id This group defines attributes of an IPv6 prefix.
prefix-ipv6-source-router-id ipv6-source-router-id This group defines the IPv6 source router ID of a prefix advertisement.
prefix-reachability-attributes external-prefix-flag readvertisement-flag node-flag This group defines extended reachability attributes of an IPv4 or IPv6 prefix.
priority-cfg value This grouping leaf describes the priority of the interface for DIS election.
route-content metric tag route-type This group add isis-specific route properties.
route-preference-global-cfg granularity This grouping defines how route preference is configured.
spf-log spf-log Grouping for spf-log events.
system-counters system-counters Grouping for system counters.

RPC Methods

RPC Abstract
clear-adjacency This RPC request clears a particular set of ISIS adjacencies. If the operation fails for ISIS internal reason, then error-tag and error-app-tag should be set to a meaningful value.
clear-database This RPC request clears a particular ISIS database. If the operation fails for ISIS internal reason, then error-tag and error-app-tag should be set to a meaningful value.

Notifications

Notification Abstract
adjacency-state-change This notification is sent when an ISIS adjacency moves to Up state or to Down state.
area-mismatch 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 a 5 second gap.
attempt-to-exceed-max-sequence This notification is sent when the system wraps the 32-bit sequence counter of an LSP.
authentication-failure This notification is sent when the system receives a PDU with the wrong authentication information. The notification generation must be throttled with at least a 5 second gap.
authentication-type-failure 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 a 5 second gap.
corrupted-lsp-detected This notification is sent when we find that an LSP that was stored in memory has become corrupted.
database-overload This notification is sent when an ISIS instance overload condition changes.
id-len-mismatch 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 a 5 second gap.
if-state-change This notification is sent when an interface state change is detected.
lsp-error-detected This notification is sent when the system receives a LSP with a parse error. The notification generation must be throttled with at least a 5 second gap.
lsp-generation This notification is sent when a LSP is regenerated. The notification generation must be throttled with at least a 5 second gap.
lsp-received This notification is sent when a LSP is received. The notification generation must be throttled with at least a 5 second gap.
lsp-too-large 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 a 5 second gap.
max-area-addresses-mismatch 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 a 5 second gap.
own-lsp-purge This notification is sent when the system receives a PDU with its own system ID and zero age.
protocols-supported-mismatch This notification is sent when the system receives a non pseudonode LSP that has no matching protocol supported. The notification generation must be throttled with at least a 5 second gap.
rejected-adjacency 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 a 5 second gap.
sequence-number-skipped This notification is sent when the system receives a PDU with its own system ID and different contents. The system has to reissue the LSP with a higher sequence number.
version-skew 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 a 5 second gap.