models/openconfig/src/main/yang/isis/openconfig-isis@2017-07-26.yang

module openconfig-isis {

  yang-version "1";

  // namespace
  namespace "http://openconfig.net/yang/openconfig-isis";

  prefix "oc-isis";

  // import some basic types
  import ietf-inet-types { prefix "inet"; }
  import ietf-yang-types { prefix "yang"; }
  import openconfig-types { prefix "oc-types"; }
  import openconfig-isis-types { prefix "oc-isis-types"; }
  import openconfig-routing-policy { prefix "oc-rpol"; }
  import openconfig-extensions { prefix "oc-ext"; }
  import openconfig-interfaces { prefix "oc-if"; }
  import openconfig-segment-routing { prefix "oc-sr"; }
  // TODO(robjs): Import authentication and keychain following merge of these
  // modules.
  //import openconfig-authentication-types { prefix "oc-auth-types"; }
  //import openconfig-keychain { prefix "oc-keychain"; }

  // Include submodules:
  // IS-IS LSP is the LSDB for IS-IS.
  include openconfig-isis-lsp;
  // IS-IS RT is routing-related features for IS-IS
  include openconfig-isis-routing;

  // meta
  organization
    "OpenConfig working group";

  contact
    "OpenConfig working group
    www.openconfig.net ";

  description
    "This module describes a YANG model for ISIS protocol configuration.
    It is a limited subset of all of the configuration parameters
    available in the variety of vendor implementations, hence it is
    expected that it would be augmented with vendor - specific configuration
    data as needed. Additional modules or submodules to handle other
    aspects of ISIS configuration, including policy, routing, types,
    LSDB and additional address families are also expected. This model
    supports the following ISIS configuration level hierarchy:

    ISIS
    +-> { global ISIS configuration}
        +-> levels +-> { level config}
            +-> { system-level-counters }
            +-> { level link-state-database}
        +-> interface +-> { interface config }
            +-> { circuit-counters }
            +-> { levels config }
            +-> { level adjacencies }";

  oc-ext:openconfig-version "0.3.2";

  revision "2017-07-26" {
    description
      "Update LSDB and fix bugs.";
    reference "0.3.2";
  }

  revision "2017-05-15" {
    description
      "Refactor LSDB.";
    reference "0.3.0";
  }

  revision "2017-01-13" {
    description
      "Remove top-level /isis container";
    reference "0.2.1";
  }

  revision "2016-12-15" {
    description
      "Add segment routing to IS-IS module";
    reference "0.2.0";
  }

  revision "2016-10-18" {
    description
      "Initial revision of IS-IS models.";
    reference "0.1.0";
  }

  // extension statements

  // feature statements

  // identity statements

  // typedef statements

  // grouping statements

  grouping isis-global-config {
    description
      "This grouping defines lobal configuration options for ISIS router.";

    // multi-instance
    leaf instance {
      type string;
      default 0;
      description
        "ISIS Instance.";
    }

    leaf-list net {
      type oc-isis-types:net;
      description
        "ISIS network entity title (NET). The first 8 bits are usually
        49 (private AFI), next 16 bits represent area, next 48 bits represent
        system id and final 8 bits are set to 0.";
      reference
        "International Organization for Standardization, Information
        technology - Open Systems Interconnection-Network service
        Definition - ISO/ IEC 8348:2002.";
    }

    leaf maximum-area-addresses {
      type uint8;
      default 3;
      description
        "Maximum areas supported.";
    }

    leaf level-capability {
      type oc-isis-types:level-type;
      default "LEVEL_1_2";
      description
        "ISIS level capability(level-1, level-2,vlevel-1-2).";
    }

    leaf max-ecmp-paths {
      type uint8;
      description
        "ISIS max-paths count.";
    }

    leaf poi-tlv {
      type boolean;
      default false;
      description
        "ISIS purge TLV. When set to true, a TLV is added to purges to record
         the system ID  of the IS generating the purge.";
      reference "RFC6232: Purge Originator Identification TLV for IS-IS. TLV 13.";
    }

    leaf iid-tlv {
      type boolean;
      default false;
      description
        "ISIS Instance Identifier TLV. When set to trues, the IID-TLV identifies
        the unique instance as well as the topology/topologies to which the
        PDU applies.";
      reference "RFC6822: IS-IS Multi-Instance. TLV 7";
    }

    leaf fast-flooding {
      type boolean;
      default true;
      description
        "When set to true, IS will always flood the LSP that triggered an SPF
     before the router actually runs the SPF computation.";
    }
  }

  grouping admin-config {
    description
      "Re-usable grouping to enable or disable a particular IS-IS feature.";

    leaf enabled {
      type boolean;
      default false;
      description
        "When set to true, the functionality within which this leaf is
        defined is enabled, when set to false it is explicitly disabled.";
    }
  }

  grouping isis-bfd-config {
    description
      "This grouping defines Bidirectionl-Forwarding-Detection
      configuration.";

    //There is also BFD state under adjacency
    leaf bfd-tlv {
      type boolean;
      description
        "When set to true, BFD TLV is used. This enables support for the IS-IS
        BFD TLV options, which specify that a BFD session must be established
        before an IS-IS adjacency can transition to the established state.
        This option should be enabled on all IS-IS neighbors on a shared
        interface.";
      reference "RFC6213. TLV 148";
    }
    reference "RFC5880: Bidirectional Forwarding Detection (BFD).";
  }

  grouping isis-authentication-check-config {
    description
      "This grouping defines ISIS authentication check.";

    leaf authentication-check {
      type boolean;
      default true;
      description
        "When set to true, reject all ISIS protocol PDUs that either have a mismatch
        in authentication-type or authentication-key.";
    }
  }

  grouping isis-metric-style-config {
    description
      "This grouping defines ISIS metric style.";

    leaf metric-style {
      type oc-isis-types:metric-style;
      description
        "ISIS metric style types(narrow, wide).";
    }
  }

  grouping authentication-key-config {
    description
      "This grouping defines authentication key configuration.";

    leaf auth-password {
      type oc-types:routing-password;
      description
        "Authentication key string.";
    }
  }

  grouping keychain-base-group {
    description
      "This grouping defines keychain configuration.";

    container keychain {
      description
        "This container defines keychain parameters.";

      // TODO(robjs): Import keychain parameters following merge of the auth
      // models.
      //uses oc-keychain:keychain-common-base;
      //uses oc-keychain:tolerance-base;
      //uses oc-keychain:keychain-key-base;
    }
  }

  grouping isis-authentication-config {
    description
      "This grouping defines ISIS authentication configuration.";

    // TODO(robjs): Add authentication following merge of auth modules.
    //leaf auth-type {
    //  type oc-auth-types:auth-type;
    //  description
    //    "ISIS authentication type (key, key-chain).";
    //}

    leaf csnp-authentication {
      type boolean;
      default false;
      description
        "Enable or disable for IS-IS CSNPs.";
    }

    leaf psnp-authentication {
      type boolean;
      default false;
      description
        "Enable or disable authentication for IS-IS PSNPs.";
    }

    leaf lsp-authentication {
      type boolean;
      default false;
      description
        "Enable or disable authentication for IS-IS LSPs.";
    }
  }

  grouping isis-authentication-group {
   description
     "This grouping defines ISIS authentication.";

    container config {
      description
        "This container defines ISIS authentication configuration.";

      uses isis-authentication-config;
    }

    container state {
      config false;
      description
        "This container defines ISIS authentication state.";

      uses isis-authentication-config;
    }

    container key {
      description
        "This container defines ISIS authentication key";
      container config {
        description
          "This container defines ISIS authentication key configuration.";

        uses authentication-key-group-config {
          when "../auth-type = KEY";
        }
      }

      container state {
        config false;
        description
          "This container defines ISIS authentication key state.";

        uses authentication-key-group-config {
          when "../auth-type = KEY";
        }
      }
    }

    uses keychain-base-group  {
      when "../auth-type = KEY_CHAIN";
    }
  }

  grouping isis-hello-authentication-config {
    description
      "Configuration options for IS-IS hello authentication.";

    leaf hello-authentication {
      type boolean;
      default false;
      description
        "Enabled or disable ISIS Hello authentication.";
    }

    // TODO(robjs): Add hello-auth-type following merge of auth models.
    //leaf hello-auth-type {
    //  type oc-auth-types:auth-type;
    //  description
    //    "ISIS authentication type (key, key-chain).";
    //}
  }

  grouping isis-hello-authentication-group {
    description
      "This grouping defines ISIS hello-authentication.";

    container config {
      description
        "This container defines ISIS authentication configuration.";

      uses isis-hello-authentication-config;
    }

    container state {
      config false;
      description
        "This container defines ISIS authentication state.";

      uses isis-hello-authentication-config;
    }

    container key {
      description
        "This container defines ISIS authentication key";

      container config {
        description
          "This container defines ISIS authentication key configuration.";

        uses authentication-key-group-config {
          when "../auth-type = KEY";
        }
      }

      container state {
        config false;
        description
          "This container defines ISIS authentication key state.";

        uses authentication-key-group-config {
          when "../auth-type = KEY";
        }
      }
    }

    uses keychain-base-group  {
      when "../auth-type = KEY_CHAIN";
    }
  }

  grouping isis-ldp-igp-config {
    description
      "This grouping defines ISIS/LDP Synchronization configuration.";

    leaf enabled {
      type boolean;
      default true;
      description
        "When set to true, rely on IGP/LDP synchronization. IGP cost for
     link is maintained at max until LDP adjacencies are established ";
      reference "RFC5443: LDP IGP Synchronization.";
    }

    leaf post-session-up-delay {
      type uint16;
      units seconds;
      description
        "Specifies a delay, expressed in units of seconds,
        between the LDP session to the IGP neighbor being established, and
        it being considered synchronized by the IGP.";
    }
  }

  grouping isis-te-config {
    description
      "This grouping defines ISIS Traffic Engineering configuration.";

    leaf ipv4-router-id {
      type inet:ipv4-address-no-zone;
      description
        "IPv4 MPLS Traffic Engineering Router-ID.";
    }

    leaf ipv6-router-id {
      type inet:ipv6-address-no-zone;
      description
        "IPv6 MPLS Traffic Engineering Router-ID.";
    }
  }

  grouping isis-reference-bandwidth-config {
    description
      "This grouping defines ISIS Reference Bandwidth Configuration.";

    leaf reference-bandwidth {
      type uint32;
      description
        "ISIS Reference Bandwidth value";
    }
  }

  grouping isis-overload-bit-set-config {
    description
      "This grouping defines ISIS Overload Bit.";

    leaf set-bit {
      type boolean;
      default false;
      description
        "When set to true, IS-IS overload bit is set.";
    }

    leaf set-bit-on-boot {
      type boolean;
      default false;
      description
        "When set to true, the IS-IS overload bit is set on system boot.";
    }

    leaf advertise-high-metric {
      type boolean;
      default false;
      description
        "When set to true, the local IS advertises links with the highest
        available metric regardless of their configured metric. The metric
        value is based on the metric style - if wide metrics are utilised
        the metric is advertised as 16777214, otherwise they are advertised
        with a value of 63.";
    }
  }

  grouping isis-overload-bit-reset-config {
    description
      "This grouping defines ISIS Overload Bit Reset Triggers";

    leaf reset-trigger {
      type identityref {
          base oc-isis-types:OVERLOAD_RESET_TRIGGER_TYPE;
      }
      description
        "In the case that the system sets the overload bit on start, the
        system should reset the bit (i.e., clear the overload bit) upon
        the specified trigger.";
    }

    leaf delay {
      type uint16;
      units seconds;
      description
        "If a reset trigger is specified, the system should delay resetting
        the overload bit for the specified number of seconds after the
        trigger occurs.";
    }
  }

  grouping isis-attached-bit-config {
    description
      "This grouping defines ISIS Attached Bit";

    leaf ignore-bit {
      type boolean;
      default false;
      description
        "When set to true, if the attached bit is set on an incoming Level 1
        IS-IS, the local system ignores it. In this case the local system
        does not set a default route to the L1L2 router advertising the PDU
        with the attached bit set.";
    }

    leaf suppress-bit {
      type boolean;
      default false;
      description
        "When set to true, if the local IS acts as a L1L2 router, then the
        attached bit is not advertised in locally generated PDUs.";
    }
  }

  grouping overload-bit-group {
    description
      "This grouping defines ISIS Overload Bit.";

    container config {
      description
        "This container defines ISIS Overload Bit configuration.";

      uses isis-overload-bit-set-config;
    }

    container state {
      config false;
      description
        "This container defines state for ISIS Overload Bit.";

      uses isis-overload-bit-set-config;
    }

    container reset-triggers {
      description
        "This container defines state for ISIS Overload Bit reset triggers";

      list reset-trigger {
        key "reset-trigger";

        description
          "This list describes ISIS Overload reset trigger reasons.";

        leaf reset-trigger {
          type leafref {
            path "../config/reset-trigger";
          }
          description
            "Reference to the reset trigger reason";
        }

        container config {
          description
            "This container defines ISIS Overload Bit reset trigger
            configuration.";

          uses isis-overload-bit-reset-config;
        }

        container state {
          config false;
          description
            "This container defines state for ISIS Overload Bit reset
            triggers.";

          uses isis-overload-bit-reset-config;
        }
      }
    }
  }


  grouping isis-base-level-config {
    description
      "This grouping defines ISIS Level configuration.";

    leaf level-number {
      type oc-isis-types:level-number;
      description
        "ISIS level number (level-1, level-2).";
    }
  }

  grouping isis-interface-level-config {
    description
      "This grouping defines ISIS Interface Level configuration.";

    leaf level-number {
      type oc-isis-types:level-number;
      description
        "ISIS level number(level-1, level-2).";
    }

    leaf passive {
      type boolean;
      default false;
      description
        "ISIS passive interface admin enable/disable function.";
    }

    leaf priority {
      type uint8 {
        range "0 .. 127";
      }
      description
        "ISIS neighbor priority(LAN hello PDU only).";
    }
  }

  grouping isis-hello-timers-config {
    description
      "This grouping defines ISIS hello timers configuration.";

    leaf hello-interval {
      type uint32;
      description
        "ISIS hello-interval value.";
    }

    leaf hello-multiplier {
      type uint8;
      description
        "ISIS hello-multiplier value.";
    }
  }

  grouping isis-interface-config {
    description
      "This grouping defines ISIS interface configuration.";

    leaf interface-id {
      type oc-if:interface-id;
      description
        "Interface for which ISIS configuration is to be applied.";
    }

    leaf passive {
      type boolean;
      default false;
      description
        "When set to true, the referenced interface is a passive interface
        such that it is not eligible to establish adjacencies with other
        systems, but is advertised into the IS-IS topology.";
    }

    leaf hello-padding {
      type oc-isis-types:hello-padding-type;
      description
        "This leaf controls padding type for IS-IS Hello PDUs.";
    }

    leaf circuit-type {
      type oc-isis-types:circuit-type;
      description
        "ISIS circuit type (p2p, broadcast).";
    }
  }

  grouping isis-adaptive-timers-state {
    description
      "This grouping defines ISIS adaptive timers state";

    leaf adaptive-timer {
      type oc-isis-types:adaptive-timer-type;
        description
          "ISIS adaptive timer types (linear, exponential).";
    }
  }

  grouping isis-lsp-generation-timers-config {
    description
      "This grouping defines ISIS LSP Generation timers configuration";

    leaf lsp-max-wait-interval {
      type uint64;
      units milliseconds;
      description
        "Time interval in milliseconds that specifies max interval between
         two consecutive occurrences of an LSP being generated.";
    }

    leaf lsp-first-wait-interval {
      type uint64;
      units milliseconds;
      description
        "Time interval in milliseconds that specifies the first LSP generation
        delay.";
    }

    leaf lsp-second-wait-interval {
      type uint64;
      units milliseconds;
      description
        "Time interval in milliseconds that specifies the millisecond LSP
         generation delay.";
    }
  }

  grouping isis-lsp-timers-config {
    description
      "This grouping defines ISIS LSP timers configuration";

    leaf lsp-lifetime-interval {
      type uint16;
      units seconds;
      default 1200;
      description
        "Time interval in seconds that specifies how long an LSP remains in
        LSDB without being refreshed.";
    }

    leaf lsp-refresh-interval {
      type uint16;
      units seconds;
      description
        "Time interval in seconds that specifies how often route topology
         that a device originates is transmitted in LSPs.";
    }
  }

  grouping isis-spf-timers-config {
    description
      "This grouping defines ISIS SPF timers configuration.";

    leaf spf-hold-interval {
      type uint64;
      units milliseconds;
      default 5000;
      description
        "SPF Hold Down time interval in milliseconds.";
    }

    leaf spf-first-interval {
      type uint64;
      units milliseconds;
      description
        "Time interval in milliseconds between the
        detection of topology change and when the SPF algorithm runs.";
    }
    leaf spf-second-interval {
      type uint64;
      units milliseconds;
      description
        "Time interval in milliseconds between the first and second
         SPF calculation.";
    }
  }

  grouping isis-interface-timers-config {
    description
      "This grouping defines ISIS interface timers configuration.";

    leaf csnp-interval {
      type uint16;
      units seconds;
      description
        "The interval, specified in seconds, at which periodic CSNP packets
        should be transmitted by the local IS.";
    }

    leaf lsp-pacing-interval {
      type uint64;
      units milliseconds;
      description
        "The interval interval in milliseconds between the
        detection of topology change and when the SPF algorithm runs.";
    }
  }

  grouping isis-transport-config {
    description
      "This grouping defines configuration parameters relating to the
      transport protocol used by the ISIS.";

    leaf lsp-mtu-size {
      type uint16;
      description
        "The maximum size in bytes of an IS-IS Link state PDU.";
    }
  }

  grouping isis-graceful-restart-config {
    description
      "This grouping defines ISIS graceful restart configuration.";

    leaf helper-only {
      type boolean;
      description
        "Enable or disable the IS-IS graceful restart helper function. When
        this leaf is set, the local system does not utilise the IS-IS
        graceful restart procedures during its own restart, but supports
        retaining forwarding information during a remote speaker's restart.";
    }
    reference "RFC 5306: Restart Signaling for IS-IS.";
  }

  // configuration context containers
  grouping inter-level-propagation-policies-structural {
    description
      "Propagate prefixes between IS-IS levels.";

    container inter-level-propagation-policies {
      description
        "Policies to propagate prefixes between IS-IS levels.";

      container level1-to-level2 {
        description
          "Policies relating to prefixes to be propagated from
          Level 1 to Level 2.";

        container config {
          description
            "Configuration parameters relating to the propagation
            of prefixes from IS-IS Level 1 to Level 2.";

          uses inter-level-propagation-policy-config;
        }

        container state {
          config false;
          description
            "Operational state parameters relating to the
            propagation of prefixes from IS-IS Level 1 to Level 2.";

          uses inter-level-propagation-policy-config;
        }

      }

      container level2-to-level1 {
        description
          "Policies relating to prefixes to be propagated from
           Level2 to Level 1.";

        container config {
          description
            "Configuration parameters relating to the propagation
            of prefixes from IS-IS Level 2 to Level 1.";

          uses inter-level-propagation-policy-config;
        }

        container state {
          config false;
          description
            "Operational state parameters relating to the propagation
            of prefixes from IS-IS Level 2 to Level 1.";

          uses inter-level-propagation-policy-config;
        }
      }
    }
  }

  grouping inter-level-propagation-policy-config {
    description
      "Policy governing the propagation of prefixes between levels.";

    uses oc-rpol:apply-policy-import-config;
  }

  grouping authentication-key-group-config {
    description
      "This grouping defines ISIS authentication key configuration.";

    uses authentication-key-config;

    // TODO(robjs): Add crypto-algorithm after merge of authentication modules.
    //leaf crypto-algorithm {
    //  type identityref {
    //    base oc-auth-types:CRYPTO_TYPE;
    //  }
    //  description
    //    "Authentication key cryptographic algorithm to be used for key encryption.";
    //}
  }

  grouping isis-global-base {
    description
      "This grouping describes ISIS Global router.";

    container config {
      description
        "This container defines ISIS global configuration router.";

      uses isis-authentication-check-config;
      uses isis-global-config;
    }

    container state {
      config false;
      description
        "This container defines state for ISIS global router.";

      uses isis-authentication-check-config;
      uses isis-global-config;
    }

    container lsp-bit {
      description
        "This container defines ISIS LSP Operational Bits.";

      container overload-bit {
        description
          "This container defines Overload Bit configuration.";
        uses overload-bit-group;
      }

      container attached-bit {
        description
          "This container defines Attached Bit.";

        container config {
          description
            "This container defines Attached Bit configuration.";

          uses isis-attached-bit-config;
        }

        container state {
          config false;
          description
            "This container defines state for Link State PDU Bit.";

          uses isis-attached-bit-config;
        }
      }
    }

    container reference-bandwidth {
      description
        "This container defines ISIS Reference Bandwidth.";

      container config {
        description
          "This container defines Reference Bandwidth configuration";
        uses isis-reference-bandwidth-config;
      }

      container state {
        config false;
        description
          "This container defines state for Reference Bandwidth.";

        uses isis-reference-bandwidth-config;
      }
    }

    container nsr {
      description
        "This container defines ISIS Non-Stop Routing.";

      container config {
        description
          "This container defines Non-Stop-Routing configuration.";

        uses admin-config;
      }

      container state {
        config false;
        description
          "This container defines state for Non-Stop-Routing";

        uses admin-config;
      }
    }

    container graceful-restart {
      description
        "This container defines ISIS Graceful Restart.";

      container config {
        description
          "This container defines ISIS graceful-restart configuration.";

        uses admin-config;
        uses isis-graceful-restart-config;
      }

      container state {
        config false;
        description
          "This container defines state information for ISIS graceful-restart.";

        uses admin-config;
        uses isis-graceful-restart-config;
      }
    }

    container timers {
      description
        "This container defines ISIS timers.";

      container config {
        description
          "This container defines ISIS global timers configuration.";

        uses isis-lsp-timers-config;
      }

      container state {
        config false;
        description
          "This container defines state information for ISIS global timers.";

        uses isis-lsp-timers-config;
      }

      container spf {
        description
          "This container defines ISIS SPF timer settings.";

        container config {
          description
            "This container defines ISIS SPF timers configuration.";

          uses isis-spf-timers-config;
        }

        container state {
         config false;
         description
          "This container defines state information for ISIS SPF timers.";

         uses isis-spf-timers-config;
         uses isis-adaptive-timers-state;
       }
      }

      container lsp-generation {
        description
          "This container defines ISIS LSP Generation.";

        container config {
          description
            "This container defines ISIS LSP Generation timers
            configuration.";

          uses isis-lsp-generation-timers-config;
        }

        container state {
          config false;
          description
            "This container defines state information for ISIS LSP Generation
            timers.";

          uses isis-lsp-generation-timers-config;
          uses isis-adaptive-timers-state;
        }
      }
    }

    container transport {
      description
        "This container defines ISIS transport.";

      container config {
        description
          "This container defines ISIS transport related configuration.";

        uses isis-transport-config;
      }

      container state {
        config false;
        description
          "This container defines state information for ISIS transport
          parameters.";

        uses isis-transport-config;
      }
    }

    container mpls {
      description
        "Configuration and operational state relating to MPLS-related
        features in IS-IS";

      container igp-ldp-sync {
        description
          "Configuration and operational state relating to synchronisation
          between the LDP and IS-IS";

        container config {
          description
            "This container defines ISIS/IGP configuration.";

          uses isis-ldp-igp-config;
        }

        container state {
          config false;
          description
            "This container defines state information for ISIS/LDP Sync.";

          uses isis-ldp-igp-config;
        }
      }
    }

    container igp-shortcuts {
      description
        "This container defines IGP shortcuts configuration and state
        information.";

      uses isis-shortcuts-afi-list;
    }

    container afi-safi {
      description
        "This container defines address-family specific configuration
        and state information.";

      uses isis-afi-safi-list;
    }

    uses oc-sr:sr-igp-top;
  }

  grouping isis-route-preference-config {
    description
      "This grouping defines ISIS route preference configuration";

    leaf external-route-preference {
      type uint8 {
        range "1..max";
      }
      description
        "Administrative Distance(preference) for external ISIS routes.";
    }

    leaf internal-route-preference {
      type uint8 {
        range "1..max";
      }
      description
        "Administrative Distance(preference) for internal ISIS routes.";
    }
  }

  grouping isis-interfaces {
    description
      "This grouping defines ISIS interfaces configured on local system.";

    list interface {
      key "interface-id";

      description
        "This list contains ISIS interfaces.";

      leaf interface-id {
        type leafref {
          path "../config/interface-id";
        }
        description
          "Reference to interface-id";
      }

      uses isis-interface-group;
      uses oc-if:interface-ref;
    }
  }

  grouping isis-interface-group {
    description
      "This grouping defines ISIS interfaces configured on local system.";

    container config {
      description
        "This container defines ISIS interface configuration.";

      uses admin-config;
      uses isis-interface-config;
    }

    container state {
      config false;
      description
        "This container defines state information for ISIS interfaces.";

      uses admin-config;
      uses isis-interface-config;
    }

    container circuit-counters {
      description
        "This container defines state information for ISIS circuit counters.";

      uses circuit-counters-structural;
    }

    container authentication {
      description
        "This container defines ISIS authentication.";

      uses isis-hello-authentication-group;
    }

    container afi-safi {
      description
        "This container defines address-family specific configuration
        and state information.";

      uses isis-if-global-afi-safi-list;
    }

    container levels {
      description
        "This container defines ISIS level specific configuration and
        state information.";

      uses isis-interface-levels;
    }

    container timers {
      description
        "This container describes ISIS interface timers configuration";

      container config {
        description
          "Configuration parameters relating to interface
          timers for IS-IS";

        uses isis-interface-timers-config;
      }

      container state {
        config false;
        description
          "This container defines state information for ISIS interface timers.";

        uses isis-interface-timers-config;
      }
    }

    container bfd {
      //TODO(bogdanov): Integrate BFD model/module
      description
        "This container defines BFD.";

      container config {
        description
          "This container defines BFD configuration parameters.";

        uses isis-bfd-config;
      }

      container state {
        config false;
        description
          "This container defines BFD state information.";

        uses isis-bfd-config;
      }
    }
  }

  grouping isis-levels {
    description
      "This grouping defines global ISIS Levels.";

    list level {
      key "level-number";

      description
        "Configuration and operational state parameters related to a
        particular level within the IS-IS protocol instance";

      leaf level-number {
        type leafref {
          path "../config/level-number";
        }
        description
          "Reference to ISIS level-number.";
      }

      uses isis-level-group;
    }
  }

  grouping isis-interface-levels {
    description
      "This grouping defines ISIS interface Levels.";

    list level {
      key "level-number";
      description
        "Configuration and operational state parameters related to a
        particular level on an IS-IS enabled interface.";

      leaf level-number {
        type leafref {
          path "../config/level-number";
        }
        description
          "Reference to ISIS level-number.";
      }

      uses isis-interface-level-group;
    }
  }

  grouping isis-level-group {
    description
      "This grouping defines ISIS level configuration and state
      information.";

    container config {
      description
        "This container defines ISIS level based configuration.";

      uses admin-config;
      uses isis-base-level-config;
      uses isis-metric-style-config;
      uses isis-authentication-check-config;
    }

    container state {
      config false;
      description
        "This container defines ISIS level state information.";

      uses admin-config;
      uses isis-base-level-config;
      uses isis-metric-style-config;
      uses isis-authentication-check-config;
    }

    container system-level-counters {
      description
        "This container defines ISIS system level counters.";

      uses system-level-counters-structural;
    }

    container link-state-database {
      config false;
      description
        "This container defines ISIS LSDB.";

      list lsp {
        key "lsp-id";
        description
          "This list describes LSPs in the LSDB.";
        uses lsp-state;
      }
    }

    container traffic-engineering {
      description
        "This container defines ISIS TE.";

      container config {
        description
          "This container defines ISIS TE configuration.";

        uses admin-config;
        uses isis-te-config;
      }

      container state {
        config false;
        description
          "This container defines ISIS TE state information.";

        uses admin-config;
        uses isis-te-config;
      }
    }

    container route-preference {
      description
        "This container defines Administrative Distance (or preference)
        assigned to ISIS routes (level1 internal, level2 internal, level1
        external, level2 external).";

      container config {
        description
          "This container defines route preference configuration.";
        uses isis-route-preference-config;
      }

      container state {
        config false;
        description
          "This container defines ISIS route preference state information.";
        uses isis-route-preference-config;
      }
    }

    container authentication {
      description
        "This container defines ISIS authentication.";
      uses isis-authentication-group;
    }

  }

  grouping isis-interface-level-group {
    description
      "This grouping defines ISIS interface level.";

    container config {
      description
        "This container defines interface ISIS level configuration.";

      uses isis-interface-level-config;
      uses admin-config;
    }

    container state {
      config false;
      description
        "This container defines interface ISIS level state information.";

      uses isis-interface-level-config;
      uses admin-config;
    }

    container packet-counters {
      description
        "This container defines ISIS interface packet counters.";

      uses packet-counters-structural;
    }

    container adjacencies {
      config false;
      description
        "This container defines ISIS adjacencies.";

      list adjacency {
        key "system-id";

        description
          "List of the local system's IS-IS adjacencies.";

        leaf system-id {
          type leafref {
            path "../state/system-id";
          }
          description
            "Reference to the IS neighbor.";
        }

        container state {
          description
            "Operational state relating to the IS-IS adjacency with the
            remote system";

          uses adjacency-state;
        }
      }
    }

    container timers {
      description
        "This container defines ISIS timers.";

      container config {
        description
          "This container defines ISIS interface hello-timers configuration.";

        uses isis-hello-timers-config;
      }

      container state {
        config false;
        description
          "This container defines ISIS interface hello-timers state.";

        uses isis-hello-timers-config;
      }
    }

    container afi-safi {
      description
        "This container defines address-family specific configuration
        and state information.";

      uses isis-if-afi-safi-list;
    }

    container hello-authentication {
      description
        "This container defines ISIS authentication.";

      uses isis-hello-authentication-group;
    }
  }


  grouping isis-top {
    description
      "This grouping define top-level ISIS model data.";

    container isis {
      description
        "This container defines top-level ISIS configuration and state
        information.";

      container global {
        description
          "This container defines global ISIS configuration and state
          information.";

        uses isis-global-base;
        uses inter-level-propagation-policies-structural;
      }

      container levels {
        description
          "This container defines ISIS level configuration and state
          information.";
        uses isis-levels;
      }

      container interfaces {
        description
          "This container defines global ISIS interface configuration and
          state information.";
        uses isis-interfaces;
      }
    }
  }

  grouping adjacency-state {
    description
      "This grouping defines ISIS adjacency.";

    leaf system-id {
     type oc-isis-types:system-id;
      description
        "ISIS neighbor system-id.";
    }

    leaf neighbor-ipv4-address {
      type inet:ipv4-address-no-zone;
      description
        "ISIS Neighbor IPv4 address.";
    }

    leaf neighbor-ipv6-address {
      type inet:ipv6-address-no-zone;
      description
        "ISIS Neighbor IPv6 address.";
    }

    leaf neighbor-snpa {
      type oc-isis-types:snpa;
      description
        "ISIS neighbor SNPA.";
    }

    leaf local-extended-circuit-id {
      type oc-isis-types:extended-circuit-id;
      description
        "Local extended circuit ID.";
    }
    leaf neighbor-extended-circuit-id {
      type oc-isis-types:extended-circuit-id;
      description
        "ISIS neighbor extended circuit ID.";
    }

    leaf priority {
      type uint8 {
        range "0..127";
      }
      description
        "Priority of the neighboring IS(LAN Hello only).";
    }

    leaf dis-system-id {
      type oc-isis-types:system-id;
      description
        "DIS System ID(LAN hello only).";
    }

    leaf neighbor-circuit-type {
      type oc-isis-types:level-type;
      description
        "Received ISIS circuit type (level-1, level-2, level-1-2).";
    }

    leaf adjacency-type {
      type oc-isis-types:level-type;
      description
        "Formed ISIS adjacency type(level-1, level-2, level-1-2).";
    }

    leaf adjacency-state {
      type oc-isis-types:isis-interface-adj-state;
      description
        "P2P 3-way ISIS adjacency state(up, down, init, failed).";
      reference "RFC4303. TLV 240.";
    }

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

    leaf up-time {
      type yang:timestamp;
      description
        "Adjacency up time.";
    }

    leaf multi-topology {
      type boolean;
      description
        "When set to true, ISIS multi-topology is supported.";
      reference "RFC5129. TLV 229.";
    }

    leaf-list topology {
      type identityref {
        base oc-isis-types:AFI_SAFI_TYPE;
      }
      description
        "ISIS topology type support(ipv4-unicast, ipv6-unicast,
        ipv4-multicast, ipv6-multicast).";
    }

    leaf restart-support {
      type boolean;
      description
        "When set to true, Graceful-restart signaling is supported.";
    }

    leaf restart-suppress {
      type boolean;
      description
        "When set to true, adjacency is not advertised. The SA bit is used by a
        starting router to  request that its neighbor suppress advertisement of
        the adjacency  to the starting router in the neighbor's LSPs.";
    }

    leaf restart-status {
      type boolean;
      description
        "When set to true, neighbor is being helped. The RR bit is used by a
        (re)starting router to signal to its neighbors that a (re)start is in
        progress.";
    }

    leaf-list area-address {
      type oc-isis-types:area-address;
      description
        "List of ISIS area-address(es).";
    }

    leaf-list nlpid {
      type enumeration {
        enum IPV4 {
          description
      "IPv4 Address family.";
        }
        enum IPV6 {
          description
      "IPv6 Address family.";
        }
      }
      description
        "Supported Protocol. IPv4 is defined as (0xcc)
        and IPv6 - (0x8e). ISIS reference is TLV 129.";
    }

    // TODO(bogdanov): update when BFD model is integrated.
    //leaf ipv4-bfd-status {
      //type oc-isis-types:bfd-state;
      //description
      //  "IPv4 BFD session status.";
    //}
    //leaf ipv6-bfd-status {
      //type oc-isis-types:bfd-state;
      //description
      //  "IPv4 BFD session status. ";
    //}

  }

  grouping packet-counters-generic-state {
    description
      "Operational state parameters relating to LSP packet counters.";

    leaf received {
      type yang:counter32;
      description
        "The number of the specified type of PDU received on the interface.";
    }
    leaf processed {
      type yang:counter32;
      description
        "The number of the specified type of PDU received on the interface
        that have been processed by the local system.";
    }
    leaf dropped {
      type yang:counter32;
      description
        "The number of the specified type of PDU received on the interface
        that have been dropped.";
    }

    leaf sent {
      type yang:counter32;
      description
        "The number of the specified type of PDU that have been sent by the
        local system on the interface.";
    }

    leaf retransmit {
      type yang:counter32;
      description
        "The number of the specified type of PDU that that have been
        retransmitted by the local system on the interface.";
    }
  }

  grouping packet-counters-structural {
    description
      "This grouping defines ISIS packet counter state.";

    container lsp {
      description
        "This container defines LSP packet counters.";

     container state {
      config false;
      description
        "This container defines LSP PDU counters.";

      uses packet-counters-generic-state;
     }
    }

    container iih {
      description
        "This container defines IIH packet counters.";

      container state {
        config false;
        description
          "Operational counters relating to IIH PDUs";

        uses packet-counters-generic-state;
      }
    }

    container ish {
      description
        "This container defines ISH packet counters.";

     container state {
      config false;
      description
        "Operational state relating to ISH PDUs.";

      uses packet-counters-generic-state;
     }
    }

    container esh {
     description
       "This container defines ESH packet counters.";
     container state {
      config false;
      description
        "Operational state relating to ESH PDUs";

      uses packet-counters-generic-state;
     }
    }

    container psnp {
     description
      "This container defines PSNP packet counters.";

      container state {
        config false;
        description
          "Packet counters relating to PSNPs.";

        uses packet-counters-generic-state;
      }
    }

    container csnp {
      description
        "Operational state parameters relating to CSNPs.";

      container state {
        config false;
        description
          "Packet counters relating to CSNPs.";

        uses packet-counters-generic-state;
      }
    }

    container unknown {
      description
        "Operational state parameters relating to IS-IS PDUs that are not
        otherwise classified - referred to as Unknown PDUs.";

      container state {
        config false;
        description
          "Packet counters relating to unknown PDUs.";

        uses packet-counters-generic-state;
      }
    }
  }

  grouping system-level-counters-state {
    description
      "IS-IS counters that are relevant to the system IS-IS context.";

    leaf corrupted-lsps {
      type yang:counter32;
      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. MIB
        Entry: SysCorrLSPs.";
    }

    leaf database-overloads {
      type yang:counter32;
      description
        "Number of times the database has become
        overloaded.
        MIB entry: SysLSPL(Level)DbaseOloads.";
    }

    leaf manual-address-drop-from-areas {
      type yang:counter32;
      description
        "Number of times a manual address has been dropped from area.
        MIB Entry: SysManAddrDropFromAreas.";
    }

    leaf exceed-max-seq-nums {
      type yang:counter32;
      description
        "The number of times the system has attempted to exceed the maximum
        sequence number. MIB Entry: SysAttmptToExMaxSeqNums.";
    }
    leaf seq-num-skips {
      type yang:counter32;
      description
        "Number of times a sequence number skip has occurred. MIB Entry:
        SysSeqNumSkips.";
    }

    leaf own-lsp-purges {
      type yang:counter32;
      description
        "Number of times a zero-aged copy of the system's
        own LSP is received from some other node.
        MIB Entry: isisSysOwnLSPPurges.";
    }

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

    leaf part-changes {
      type yang:counter32;
      description
        "The number of partition changes detected. MIB Entry: SysPartChanges.";
    }

    leaf max-area-address-mismatches {
      type yang:counter32;
      description
        "Number of times a PDU is received with a different value for
        MaximumAreaAddresses from that of the receiving system. MIB Entry:
        SysMaxAreaAddrMismatches.";
    }

    leaf auth-fails {
      type yang:counter32;
      description
        "The number of authentication key failures.
         MIB Entry: SysAuthFails.";
    }

    leaf spf-runs {
      type yang:counter32;
      description
        "The number of times SPF was ran at this level.";
    }

    leaf auth-type-fails {
      type yang:counter32;
      description
        "The number of authentication type mismatches.";
    }

    leaf lsp-errors {
      type yang:counter32;
      description
        "The number of received LSPs with errors.";
    }
  }

  grouping system-level-counters-structural {
    description
      "This grouping defines system level counters.";

    container state {
      config false;
      description
        "The container defines a list of system counters for the IS.";

      uses system-level-counters-state;
    }
  }

  grouping circuit-counters-state {
    description
      "Operational state parameters relating to counters specific to one
      interface or circuit.";

    leaf adj-changes {
      type yang:counter32;
      description
        "Number of times an adjacency state change has occurred on this circuit.
        MIB Entry: CircAdjChanges.";
    }

    leaf init-fails {
      type yang:counter32;
      description
        "Number of times initialization of this circuit has failed. This counts
        events such as PPP NCP failures. MIB Entry: CircInitFails.";
    }

    leaf rejected-adj {
      type yang:counter32;
      description
        "Number of times an adjacency has been rejected on this circuit. MIB
        Entry: CircRejAdjs.";
    }

    leaf id-field-len-mismatches {
      type yang:counter32;
      description
        "Number of times an IS-IS control PDU with an ID field length different
        from that for this system has been received.
        MIB Entry: CircIDFieldLenMismatches.";
    }

    leaf max-area-address-mismatches {
      type yang:counter32;
      description
        "Number of times an IS-IS control PDU with a max area address field
        different from that for this system has been received. MIB Entry:
        CircMaxAreaAddrMismatches.";
    }

    leaf auth-type-fails {
      type yang:counter32;
      description
        "Number of times an IS-IS control PDU with an auth type field different
        from that for this system has been received. MIB Entry:
        CircAuthTypeFails.";
    }

    leaf auth-fails {
      type yang:counter32;
      description
        "Number of times an IS-IS control PDU with the correct auth type has
        failed to pass authentication validation. MIB Entry: CircAuthFails.";
    }

    leaf lan-dis-changes {
      type yang:counter32;
      description
        "Number of times the Designated IS has changed on this circuit at this
        level. If the circuit is point to point, this count is zero. MIB Entry:
        CircLANDesISChanges.";
    }

    leaf adj-number {
      type uint32;
      description
        "Number of adjacencies on this circuit.
        MIB Entry: CircNumAdj.";
    }
  }

  grouping circuit-counters-structural {
    description
      "This grouping defines circuit counters.";

    container state {
      config false;
      description
          "The container defines a list of counters for IS circuit.";

     uses circuit-counters-state;
    }
  }
}