module isis {
    namespace "urn:netdef:isis";

    prefix isis;

    import ietf-routing {
        prefix "rt";
    }

    import ietf-inet-types {
        prefix inet;
    }

    import ietf-yang-types {
        prefix yang;
    }

    contact
        "Stephane Litkowski

         Email : stephane.litkowski@orange.com";

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


    revision 2014-06-11 {
        description "Initial revision.";
    }
    identity isis {
        base rt:routing-protocol;
        description "Identity for the ISIS routing protocol.";
    }
    typedef isis-level {
        type enumeration {
            enum level-1;
            enum level-2;
            enum level-1-2;
        }
    }

    typedef isis-wide-metric {
        type uint32 {
            range "0 .. 16777215";
        }
    }

    typedef isis-std-metric {
        type uint8 {
            range "0 .. 63";
        }
    }

    grouping isis-route-content {
        leaf metric {
            type uint32;
        }
        leaf-list tag {
            type uint32;
        }
        leaf route-type {
            type enumeration {
                enum l2-up-internal;
                enum l1-up-internal;
                enum l2-up-external;
                enum l1-up-external;
                enum l2-down-internal;
                enum l1-down-internal;
                enum l2-down-external;
                enum l1-down-external;
            }
        }
    }

    augment "/rt:routing-state/rt:ribs/rt:rib/rt:routes/rt:route" {
        when "rt:source-protocol = 'isis:isis'" {
            description "ISIS-specific route attributes.";
        }
        uses isis-route-content;
      }

    augment "/rt:active-route/rt:output/rt:route"
       {
        description "ISIS-specific route attributes.";
        uses isis-route-content;
      }


    grouping isis-prefix-ipv4-std {
        leaf up-down {
            description "This leaf expresses the value of up/down bit.";
            type boolean;
        }
        leaf i-e {
            description "This leaf expresses the value of I/E bit.";
            type boolean;
        }
        leaf ip-prefix {
            type inet:ipv4-address;
        }
        leaf prefix-len {
            type uint8;
        }
        leaf default-metric {
            type isis-std-metric;
        }
        leaf delay-metric {
            type isis-std-metric;
        }
        leaf expense-metric {
            type isis-std-metric;
        }
        leaf error-metric {
            type isis-std-metric;
        }
    }

    grouping isis-prefix-ipv4-extended {
        leaf up-down {
            description "This leaf expresses the value of up/down bit.";
            type boolean;
        }
        leaf ip-prefix {
            type inet:ipv4-address;
        }
        leaf prefix-len {
            type uint8;
        }

        leaf metric {
            type isis-wide-metric;
        }
        leaf-list SUBTLV1 {
            type uint32;
        }
    }

    grouping isis-prefix-ipv6-extended {
        leaf up-down {
            description "This leaf expresses the value of up/down bit.";
            type boolean;
        }
        leaf ip-prefix {
            type inet:ipv6-address;
        }
        leaf prefix-len {
            type uint8;
        }

        leaf metric {
            type isis-wide-metric;
        }
        leaf-list SUBTLV1 {
            type uint32;
        }
    }

    grouping isis-neighbor-extended {
        leaf system-id {
            type string;
        }
        leaf metric {
            type isis-wide-metric;
        }
    }

    grouping isis-database {
        leaf id {
            type string;
        }
        leaf checksum {
            type uint16;
        }
        leaf sequence {
            type uint32;
        }
        leaf attributes {
            type bits {
                bit PARTITIONNED;
                bit ATTACHED-ERROR;
                bit ATTACHED-EXPENSE;
                bit ATTACHED-DELAY;
                bit ATTACHED-DEFAULT;
                bit OVERLOAD;
            }
        }
        leaf isis-level {
            type isis-level;
        }

        container TLV10 {
            description "This leaf describes authentication information of the node.";
            leaf authentication-type {
                type uint8;
            }
            leaf authentication-key {
                type string;
            }
        }
        container TLV22 {
            list neighbor {
                key "system-id";
                uses isis-neighbor-extended;


            }
        }

        container TLV128 {
            list ip-internal-reachability {
                key "ip-prefix";
                uses isis-prefix-ipv4-std;
            }
        }

        leaf-list TLV129 {
            description "This leaf describes the protocol supported by the node.";
            type uint8;
        }

        container TLV130 {
            list ip-external-reachability {
                key "ip-prefix";
                uses isis-prefix-ipv4-std;
            }
        }

        leaf-list TLV132 {
            description "This leaf describes the ipv4 addresses of the node.";
            type inet:ipv4-address;
        }

        leaf TLV134 {
            description "This leaf describes the IPv4 Traffic Engineering router ID of the node.";
            type inet:ipv4-address;
        }

        container TLV135 {
            list extended-ip-reachability {
                key "ip-prefix";
                uses isis-prefix-ipv4-extended;
            }
        }

        leaf TLV137 {
            description "This leaf describes the name of the node.";
            type string;
        }

        leaf TLV140 {
            description "This leaf describes the IPv6 Traffic Engineering router ID of the node.";
            type inet:ipv6-address;
        }


        container TLV222 {
            list neighbor {
                key "system-id";
                leaf MT-ID {
                    type uint16 {
                        range "0 .. 4095";
                    }
                }
                uses isis-neighbor-extended;


            }
        }

        container TLV229 {
            description "This leaf describes the MT entries.";
            list topology {
                key "MT-ID";

                leaf MT-ID {
                    type uint16 {
                        range "0 .. 4095";
                    }
                }

                leaf attributes {
                    type bits {
                        bit OVERLOAD;
                        bit ATTACHED;
                    }
                }
            }
        }

        leaf-list TLV232 {
            description "This leaf describes the ipv6 addresses of the node.";
            type inet:ipv6-address;
        }

        container TLV235 {
            list extended-ip-reachability {
                key "ip-prefix";
                leaf MT-ID {
                    type uint16 {
                        range "0 .. 4095";
                    }
                }
                uses isis-prefix-ipv4-extended;

            }
        }

        container TLV237 {
            list extended-ip-reachability {
                key "ip-prefix";
                leaf MT-ID {
                    type uint16 {
                        range "0 .. 4095";
                    }
                }
                uses isis-prefix-ipv6-extended;

            }
        }

        container TLV236 {
            list extended-ipv6-reachability {
                key "ip-prefix";
                uses isis-prefix-ipv6-extended;
            }
        }

        container TLV242 {
            description "This leaf describes the capabilities of the node. This container may be extended with detailled information.";
            leaf binary {
                type binary;
            }
        }
    }

    grouping address-family-cfg {
        leaf ipv4-unicast {
            description "This leaf defines if IPv4 unicast is activated.";
            type boolean;
        }
        leaf ipv6-unicast {
            description "This leaf defines if IPv6 unicast is activated.";

            type boolean;
        }
        leaf ipv4-multicast {
            description "This leaf defines if IPv4 multicast is activated.";
            type boolean;
        }
        leaf ipv6-multicast {
            description "This leaf defines if IPv6 multicast is activated.";
            type boolean;
        }
    }

    grouping interface-hello-cfg {
        leaf hello-authentication-type {
            type enumeration {
                enum    none;
                enum    plaintext;
                enum    message-digest;
            }
        }
        leaf hello-authentication-key {
            type string;
        }
        leaf hello-interval {
            description "This leaf defines the interval of hello messages.";
            type uint16;
        }
        leaf hello-multiplier {
            description "This leaf defines the number of hello failed to be received before declaring the adjacency down.";
            type uint16;
        }
    }

    grouping interface-level-cfg {
        uses interface-hello-cfg;

        uses address-family-cfg;

        leaf priority {
            type uint8 {
                range "0 .. 127";
            }
        }
        leaf ipv4-unicast-metric {
            type isis-wide-metric;
        }
        leaf ipv6-unicast-metric {
            type isis-wide-metric;

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

    grouping interface-cfg {
        description "ISIS is enabled on interfaces that have an entry in this list, unless 'enabled' is set to 'false' for that entry.";
        leaf name {
            type leafref {
                path "/rt:routing/rt:routing-instance/rt:interfaces/rt:interface/rt:name";
            }
        }
        leaf level {
            description "This leaf defines the associated ISIS level of the interface.";
            type isis-level;
        }
        leaf lsp-interval {
            description "This leaf defines the interval between LSP transmissions in msec";
            type uint16;
        }
        leaf passive {
            description "This leaf defines if interface is in passive mode (ISIS not running, but network is advertised).";
            type boolean;
            default "false";
        }
        leaf csnp-interval {
            type uint16;
        }

        uses interface-hello-cfg;

        leaf hello-padding {
            description "This leaf defines if ISIS Hellos would be padded up to MTU size.";
            type boolean;
        }

        uses address-family-cfg;

        leaf interface-type {
            type enumeration {
                enum broadcast;
                enum point-to-point;
            }
        }

        leaf enabled {
            type boolean;
            default "true";
        }

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

        container level-1 {
            uses interface-level-cfg;
        }

        container level-2 {
            uses interface-level-cfg;
        }
    }

    grouping isis-authentication-cfg {
        leaf psnp-authentication {
            type boolean;
            default "true";
        }
        leaf csnp-authentication {
            type boolean;
            default "true";
        }
        leaf hello-authentication {
            type boolean;
            default "true";
        }
        leaf authentication-key {
            type string;
        }
        leaf authentication-type {
            type enumeration {
                enum    none;
                enum    plaintext;
                enum    message-digest;
            }
        }
    }

    grouping isis-level-cfg {

        leaf enabled {
            description "This leaf defines the status of the administrative status of the level (Active / not active).";
            type boolean;
            default "true";
        }

        uses isis-authentication-cfg;

        leaf metric-type {
            type enumeration {
                enum wide-only;
                enum old-only;
                enum both;
            }
        }
        leaf preference {
            description "This leaf defines the protocol preference.";
            type uint8;
        }
        leaf external-preference {
            description "This leaf defines the protocol preference for external routes.";
            type uint8;
        }
        leaf default-ipv4-unicast-metric {
            description "This leaf defines the IPv4 unicast default metric.";
            type isis-wide-metric;
        }
        leaf default-ipv6-unicast-metric {
            description "This leaf defines the IPv6 unicast default metric.";
            type isis-wide-metric;
        }
        leaf default-ipv4-multicast-metric {
            description "This leaf defines the IPv4 multicast default metric.";
            type isis-wide-metric;
        }
        leaf default-ipv6-multicast-metric {
            description "This leaf defines the IPv6 multicast default metric.";
            type isis-wide-metric;
        }
    }

    augment "/rt:routing/rt:routing-instance/rt:routing-protocols/rt:routing-protocol" {
        when "rt:type = 'isis:isis'" {
            description "This augment is only valid when routing protocol instance type is isis.";
        }
        container isis-cfg {
            container instances {
                description ".";
                list instance {
                    key "name";
                    description "Defines the list of ISIS instances.";
                    leaf name {
                        type string;
                    }
                    leaf enabled {
                        type boolean;
                        default "true";
                    }
                    leaf isis-level {
                        type isis-level;
                    }
                    leaf area-id {
                        type string;
                    }

                    leaf system-id {
                        type string;
                    }
                    leaf ipv4-router-id {
                        description "Router ID value that would be used in TLV134.";
                        type inet:ipv4-address;
                    }
                    leaf ipv6-router-id {
                        description "Router ID value that would be used in TLV234.";
                        type inet:ipv6-address;
                    }
                    leaf reference-bandwidth {
                        description "This leaf defines the bandwidth for calculating metric.";
                        type uint32;
                    }

                    leaf lsp-mtu {
                        description "This leaf describes the maximum size of a LSP PDU in bytes.";
                        type uint16;
                    }
                    leaf lsp-lifetime {
                        description "This leaf describes the lifetime of the router LSP in seconds.";
                        type uint16;
                    }
                    leaf lsp-refresh {
                        description "This leaf describes the refresh interval of the router LSP in seconds.";
                        type uint16;
                    }

                    uses isis-authentication-cfg;

                    container multi-topology-cfg {
                        description "This container describes activation of MT extensions for supporting new address families.";
                        uses address-family-cfg;
                    }

                    container isis-level-1-cfg {
                        description "Defines configuration parameters of level 1.";

                        uses isis-level-cfg;
                    }

                    container isis-level-2-cfg {
                        description "Defines configuration parameters of level 2.";

                        uses isis-level-cfg;
                    }

                    container overload {
                        description "This leaf describes if the router is set to overload state.";
                        leaf status {
                            type boolean;
                        }
                        leaf timeout {
                            type uint16;
                        }
                    }

                    container interfaces {
                        list interface {
                            key "name";
                            uses interface-cfg;
                        }
                    }
                }
            }
        }

        container isis-op {
            config false;
            container adjacencies {
                description "This container lists the adjacencies of the local node.";
                list adjacency {
                    key interface;
                    leaf interface {
                        type string;
                    }
                    leaf level {
                        type isis-level;
                    }
                    leaf state {
                        type enumeration {
                            enum "Up";
                            enum "Down";
                            enum "Init";
                        }
                    }
                }
            }
            container spf-log {
                description "This container lists the SPF computation events.";
                list event {
                    key id;

                    leaf id {
                        type uint32;
                    }
                    leaf spf-type {
                        type enumeration {
                            enum full;
                            enum incremental;
                            enum route-only;
                        }
                    }
                    leaf level {
                        type isis-level;
                    }
                    leaf spf-delay {
                        description "This leaf describes the SPF delay that was used for this event.";
                        type uint32;
                    }
                    leaf schedule-timestamp {
                        type yang:timestamp;
                    }
                    leaf start-timestamp {
                        type yang:timestamp;
                    }
                    leaf end-timestamp {
                        type yang:timestamp;
                    }
                    list trigger-lsp {
                        key "lsp";
                        leaf lsp {
                            type string;
                        }
                        leaf sequence {
                            type uint32;
                        }
                    }

                }
            }
            container lsp-log {
                description "This container lists the LSP reception events.";
                list event {
                    key id;

                    leaf id {
                        type uint32;
                    }
                    leaf level {
                        type isis-level;
                    }
                    container lsp {
                        leaf lsp {
                            type string;
                        }
                        leaf sequence {
                            type uint32;
                        }
                    }

                    leaf received-timestamp {
                        type yang:timestamp;
                    }
                }
            }
            container database {
                container level-1 {
                    list lsp {
                        key id;

                        uses isis-database;

                    }
                }
                container level-2 {
                    list lsp {
                        key id;
                        uses isis-database;
                    }
                }
            }
            container hostnames {
                list hostname {
                    key system-id;
                    leaf system-id {
                        type string;
                    }
                    leaf hostname {
                        type string;
                    }
                }
            }
        }
    }
}