module openconfig-isis {

    yang-version 1;

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

    prefix oc-isis;

    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;
    }

    include openconfig-isis-lsp;
    include openconfig-isis-routing;

    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 }";

    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";

    }

    oc-ext:openconfig-version "0.3.2";

    grouping isis-global-config {
      description
        "This grouping defines lobal configuration options for ISIS router.";
      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 isis-global-config

    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 admin-config

    grouping isis-bfd-config {
      description
        "This grouping defines Bidirectionl-Forwarding-Detection
      configuration.";
      reference
        "RFC5880: Bidirectional Forwarding Detection (BFD).";

      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";

      }
    }  // grouping isis-bfd-config

    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-authentication-check-config

    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 isis-metric-style-config

    grouping authentication-key-config {
      description
        "This grouping defines authentication key configuration.";
      leaf auth-password {
        type oc-types:routing-password;
        description
          "Authentication key string.";
      }
    }  // grouping authentication-key-config

    grouping keychain-base-group {
      description
        "This grouping defines keychain configuration.";
      container keychain {
        description
          "This container defines keychain parameters.";
      }  // container keychain
    }  // grouping keychain-base-group

    grouping isis-authentication-config {
      description
        "This grouping defines ISIS authentication configuration.";
      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-config

    grouping isis-authentication-group {
      description
        "This grouping defines ISIS authentication.";
      container config {
        description
          "This container defines ISIS authentication configuration.";
        uses isis-authentication-config;
      }  // container config

      container state {
        config false;
        description
          "This container defines ISIS authentication state.";
        uses isis-authentication-config;
      }  // container state

      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 config

        container state {
          config false;
          description
            "This container defines ISIS authentication key state.";
          uses authentication-key-group-config {
            when "../auth-type = KEY";
          }
        }  // container state
      }  // container key

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

    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.";
      }
    }  // grouping isis-hello-authentication-config

    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 config

      container state {
        config false;
        description
          "This container defines ISIS authentication state.";
        uses isis-hello-authentication-config;
      }  // container state

      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 config

        container state {
          config false;
          description
            "This container defines ISIS authentication key state.";
          uses authentication-key-group-config {
            when "../auth-type = KEY";
          }
        }  // container state
      }  // container key

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

    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-ldp-igp-config

    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-te-config

    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-reference-bandwidth-config

    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-set-config

    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-overload-bit-reset-config

    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 isis-attached-bit-config

    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 config

      container state {
        config false;
        description
          "This container defines state for ISIS Overload Bit.";
        uses isis-overload-bit-set-config;
      }  // container state

      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 config

          container state {
            config false;
            description
              "This container defines state for ISIS Overload Bit reset
            triggers.";
            uses isis-overload-bit-reset-config;
          }  // container state
        }  // list reset-trigger
      }  // container reset-triggers
    }  // grouping overload-bit-group

    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-base-level-config

    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-interface-level-config

    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-hello-timers-config

    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-interface-config

    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-adaptive-timers-state

    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-generation-timers-config

    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-lsp-timers-config

    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-spf-timers-config

    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-interface-timers-config

    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-transport-config

    grouping isis-graceful-restart-config {
      description
        "This grouping defines ISIS graceful restart configuration.";
      reference
        "RFC 5306: Restart Signaling for IS-IS.";

      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.";
      }
    }  // grouping isis-graceful-restart-config

    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 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 state
        }  // container level1-to-level2

        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 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;
          }  // container state
        }  // container level2-to-level1
      }  // container inter-level-propagation-policies
    }  // grouping inter-level-propagation-policies-structural

    grouping inter-level-propagation-policy-config {
      description
        "Policy governing the propagation of prefixes between levels.";
      uses oc-rpol:apply-policy-import-config;
    }  // grouping inter-level-propagation-policy-config

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

    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 config

      container state {
        config false;
        description
          "This container defines state for ISIS global router.";
        uses isis-authentication-check-config;

        uses isis-global-config;
      }  // container state

      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 overload-bit

        container attached-bit {
          description
            "This container defines Attached Bit.";
          container config {
            description
              "This container defines Attached Bit configuration.";
            uses isis-attached-bit-config;
          }  // container config

          container state {
            config false;
            description
              "This container defines state for Link State PDU Bit.";
            uses isis-attached-bit-config;
          }  // container state
        }  // container attached-bit
      }  // container lsp-bit

      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 config

        container state {
          config false;
          description
            "This container defines state for Reference Bandwidth.";
          uses isis-reference-bandwidth-config;
        }  // container state
      }  // container reference-bandwidth

      container nsr {
        description
          "This container defines ISIS Non-Stop Routing.";
        container config {
          description
            "This container defines Non-Stop-Routing configuration.";
          uses admin-config;
        }  // container config

        container state {
          config false;
          description
            "This container defines state for Non-Stop-Routing";
          uses admin-config;
        }  // container state
      }  // container nsr

      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 config

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

          uses isis-graceful-restart-config;
        }  // container state
      }  // container graceful-restart

      container timers {
        description
          "This container defines ISIS timers.";
        container config {
          description
            "This container defines ISIS global timers configuration.";
          uses isis-lsp-timers-config;
        }  // container config

        container state {
          config false;
          description
            "This container defines state information for ISIS global timers.";
          uses isis-lsp-timers-config;
        }  // container state

        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 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 state
        }  // container spf

        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 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 state
        }  // container lsp-generation
      }  // container timers

      container transport {
        description
          "This container defines ISIS transport.";
        container config {
          description
            "This container defines ISIS transport related configuration.";
          uses isis-transport-config;
        }  // container config

        container state {
          config false;
          description
            "This container defines state information for ISIS transport
          parameters.";
          uses isis-transport-config;
        }  // container state
      }  // container transport

      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 config

          container state {
            config false;
            description
              "This container defines state information for ISIS/LDP Sync.";
            uses isis-ldp-igp-config;
          }  // container state
        }  // container igp-ldp-sync
      }  // container mpls

      container igp-shortcuts {
        description
          "This container defines IGP shortcuts configuration and state
        information.";
        uses isis-shortcuts-afi-list;
      }  // container igp-shortcuts

      container afi-safi {
        description
          "This container defines address-family specific configuration
        and state information.";
        uses isis-afi-safi-list;
      }  // container afi-safi

      uses oc-sr:sr-igp-top;
    }  // grouping isis-global-base

    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-route-preference-config

    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;
      }  // list interface
    }  // grouping isis-interfaces

    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 config

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

        uses isis-interface-config;
      }  // container state

      container circuit-counters {
        description
          "This container defines state information for ISIS circuit counters.";
        uses circuit-counters-structural;
      }  // container circuit-counters

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

      container afi-safi {
        description
          "This container defines address-family specific configuration
        and state information.";
        uses isis-if-global-afi-safi-list;
      }  // container afi-safi

      container levels {
        description
          "This container defines ISIS level specific configuration and
        state information.";
        uses isis-interface-levels;
      }  // container 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 config

        container state {
          config false;
          description
            "This container defines state information for ISIS interface timers.";
          uses isis-interface-timers-config;
        }  // container state
      }  // container timers

      container bfd {
        description
          "This container defines BFD.";
        container config {
          description
            "This container defines BFD configuration parameters.";
          uses isis-bfd-config;
        }  // container config

        container state {
          config false;
          description
            "This container defines BFD state information.";
          uses isis-bfd-config;
        }  // container state
      }  // container bfd
    }  // grouping isis-interface-group

    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;
      }  // list level
    }  // grouping isis-levels

    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;
      }  // list level
    }  // grouping isis-interface-levels

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

      container system-level-counters {
        description
          "This container defines ISIS system level counters.";
        uses system-level-counters-structural;
      }  // container system-level-counters

      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;
        }  // list lsp
      }  // container link-state-database

      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 config

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

          uses isis-te-config;
        }  // container state
      }  // container traffic-engineering

      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 config

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

      container authentication {
        description
          "This container defines ISIS authentication.";
        uses isis-authentication-group;
      }  // container authentication
    }  // grouping isis-level-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 config

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

        uses admin-config;
      }  // container state

      container packet-counters {
        description
          "This container defines ISIS interface packet counters.";
        uses packet-counters-structural;
      }  // container packet-counters

      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 state
        }  // list adjacency
      }  // container adjacencies

      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 config

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

      container afi-safi {
        description
          "This container defines address-family specific configuration
        and state information.";
        uses isis-if-afi-safi-list;
      }  // container afi-safi

      container hello-authentication {
        description
          "This container defines ISIS authentication.";
        uses isis-hello-authentication-group;
      }  // container hello-authentication
    }  // grouping isis-interface-level-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 global

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

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

    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" {
            value 0;
            description
              "IPv4 Address family.";
          }
          enum "IPV6" {
            value 1;
            description
              "IPv6 Address family.";
          }
        }
        description
          "Supported Protocol. IPv4 is defined as (0xcc)
        and IPv6 - (0x8e). ISIS reference is TLV 129.";
      }
    }  // grouping adjacency-state

    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-generic-state

    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 state
      }  // container lsp

      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 state
      }  // container iih

      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 state
      }  // container ish

      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 state
      }  // container esh

      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 state
      }  // container psnp

      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 state
      }  // container csnp

      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;
        }  // container state
      }  // container unknown
    }  // grouping packet-counters-structural

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

    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;
      }  // container state
    }  // grouping system-level-counters-structural

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

    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;
      }  // container state
    }  // grouping circuit-counters-structural
  }  // module openconfig-isis