module Cisco-IOS-XR-mpls-traceroute-act {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-mpls-traceroute-act";

    prefix mpls-traceroute-act;

    import ietf-inet-types {
      prefix inet;
    }
    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
     for Cisco IOS-XR mpls traceroute action package configuration
     
     Copyright (c) 2020-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-04-27" {
      description
        "Added missing descriptions";
    }

    revision "2021-04-05" {
      description
        "Added range values for lsp-id and pseudowire leaf values";
    }

    revision "2021-03-25" {
      description
        "Added IP netmask leaf for MPLS and SR traceroute";
    }

    revision "2021-02-03" {
      description "Range added for EXP leaf";
    }

    revision "2020-06-05" {
      description "Initial revision.";
    }

    semver:module-version "1.0.0";

    typedef mpls-fec-type {
      type enumeration {
        enum "bgp" {
          value 0;
          description "MPLS BGP FEC";
        }
        enum "generic" {
          value 1;
          description "MPLS Generic FEC";
        }
        enum "ldp" {
          value 2;
          description "MPLS LDP FEC";
        }
      }
      description
        "MPLS Forwarding Equivalence Class type";
    }

    typedef sr-fec-type {
      type enumeration {
        enum "bgp" {
          value 0;
          description "SR IGP BGP FEC";
        }
        enum "ospf" {
          value 1;
          description "SR IGP OSPF FEC";
        }
        enum "isis" {
          value 2;
          description "SR IGP ISIS FEC";
        }
      }
      description
        "SR Forwarding Equivalence Class type";
    }

    typedef request-reply-mode {
      type enumeration {
        enum "ipv4" {
          value 0;
          description "Reply Mode IPv4";
        }
        enum "router-alert" {
          value 1;
          description
            "Reply Mode Router Alert";
        }
      }
      description "Reply mode";
    }

    rpc mpls-traceroute {
      description "Send echo messages";
      input {
        choice traceroute-type {
          mandatory true;
          description
            "Specify traceroute type";
          container mpls {
            description "MPLS traceroute";
            choice mpls-subtype {
              mandatory true;
              description
                "Traceroute MPLS subtype";
              container ipv4 {
                description
                  "Traceroute mpls IPv4 address";
                leaf ip {
                  type inet:ipv4-address;
                  mandatory true;
                  description
                    "Destination x.x.x.x of traceroute";
                }

                choice subnet {
                  mandatory true;
                  description
                    "The subnet can be specified as a prefix-length or as
                       a netmask.";
                  leaf prefix-length {
                    type uint8 {
                      range "0..32";
                    }
                    default "32";
                    description
                      "The length of the subnet prefix.";
                  }
                  leaf netmask {
                    type inet:ipv4-address;
                    description
                      "The subnet specified as a netmask";
                  }
                }  // choice subnet

                leaf fec-type {
                  type mpls-fec-type;
                  description
                    "TLV FEC type to use in request";
                }
              }  // container ipv4
              container traffic-eng {
                description
                  "Trace mpls tunnel";
                choice tunnel-identifier {
                  mandatory true;
                  description
                    "Tunnel Identifier (LSP name or tunnel-interface)";
                  leaf tunnel-name {
                    type string;
                    description
                      "Next hop tunnel lsp name";
                  }
                  leaf tunnel-interface {
                    type string;
                    description
                      "Next hop Interface with form tunnel-te<number>";
                  }
                }  // choice tunnel-identifier

                choice te-lsp-option {
                  description
                    "Specify which LSP to use";
                  leaf active-lsp {
                    type boolean;
                    description
                      "Enforce active LSP selection for tunnel";
                  }
                  leaf lsp-id {
                    type uint32 {
                      range "1..10000";
                    }
                    default "1";
                    description
                      "Tunnel Label Switched Path Identifier";
                  }
                  leaf path-protected {
                    type boolean;
                    description
                      "Test path protected LSP for tunnel";
                  }
                  leaf reoptimized {
                    type boolean;
                    description
                      "Test reoptimized LSP for tunnel";
                  }
                }  // choice te-lsp-option
              }  // container traffic-eng
            }  // choice mpls-subtype
          }  // container mpls
          container sr-mpls {
            description "Trace sr-mpls";
            choice sr-target {
              description
                "Trace sr-mpls target type";
              container ipv4 {
                description
                  "Trace sr-mpls IPv4 Prefix SID";
                leaf ip {
                  type inet:ipv4-address;
                  mandatory true;
                  description
                    "SR LSP Egress IP x.x.x.x";
                }

                choice subnet {
                  mandatory true;
                  description
                    "The subnet can be specified as a prefix-length or as
                       a netmask.";
                  leaf prefix-length {
                    type uint8 {
                      range "0..32";
                    }
                    default "32";
                    description
                      "The length of the subnet prefix.";
                  }
                  leaf netmask {
                    type inet:ipv4-address;
                    description
                      "The subnet specified as a netmask";
                  }
                }  // choice subnet

                leaf fec-type {
                  type sr-fec-type;
                  description
                    "SR OAM IGP FEC TLV type to use in request";
                }
              }  // container ipv4
              container labels {
                description
                  "Trace sr-mpls label stack (up to 12 labels)";
                list label {
                  key "index";
                  description
                    "Specify label index and value";
                  leaf index {
                    type uint32 {
                      range "0..9";
                    }
                    mandatory true;
                    description
                      "Label index";
                  }

                  leaf label {
                    type uint32 {
                      range "16..1048575";
                    }
                    mandatory true;
                    description
                      "Label value";
                  }
                }  // list label

                leaf nil-fec {
                  type boolean;
                  description
                    "Use Nil-FEC TLV and Append Explicit Null";
                }

                leaf lsp-endpoint {
                  type inet:ipv4-address;
                  description
                    "Specify the IP of the LSP endpoint";
                }
              }  // container labels
              container policy {
                description
                  "Trace sr-mpls policy";
                choice sr-policy-id {
                  mandatory true;
                  description
                    "SR Policy Identifier (binding sid or policy name)";
                  leaf bsid {
                    type uint32 {
                      range "16..1048575";
                    }
                    default "16";
                    description
                      "SR Policy Binding SID";
                  }
                  leaf name {
                    type string;
                    description
                      "SR Policy Name";
                  }
                }  // choice sr-policy-id

                leaf fec-type {
                  type sr-fec-type;
                  description
                    "SR OAM IGP FEC TLV type to use in request";
                }

                leaf nil-fec {
                  type boolean;
                  description
                    "Use Nil-FEC TLV and Append Explicit Null";
                }

                leaf lsp-endpoint {
                  type inet:ipv4-address;
                  description
                    "Specify the IP of the LSP endpoint";
                }
              }  // container policy
            }  // choice sr-target
          }  // container sr-mpls
        }  // choice traceroute-type

        container request-options-parameters {
          description
            "MPLS echo request options";
          leaf exp {
            type uint8 {
              range "0..7";
            }
            description "EXP Bits To Set";
          }

          leaf fec {
            type boolean;
            description
              "Force FEC TLV Checks";
          }

          leaf ddmap {
            type boolean;
            description
              "Use DDMAP (Default is DSMAP)";
          }

          leaf force-explicit-null {
            type boolean;
            description
              "Force explicit null to be added";
          }

          container packet-output {
            description
              "Packet output options";
            leaf interface-name {
              type string;
              description
                "Outgoing interface for echo packet";
            }

            leaf next-hop {
              type inet:ipv4-address;
              description
                "Outgoing next hop IP for echo packet";
            }
          }  // container packet-output

          container reply {
            description "Echo Reply options";
            leaf dscp {
              type uint8 {
                range "0..63";
              }
              description
                "Set DSCP reply value 0-63 (decimal)";
            }

            leaf reply-mode {
              type request-reply-mode;
              description "Echo Reply Mode";
            }
          }  // container reply

          leaf source {
            type inet:ipv4-address;
            description
              "Source IP address to use in the IP header (used as the return address for the reply)";
          }

          leaf destination {
            type inet:ipv4-address;
            description
              "Destination IP address (127.x.y.z)";
          }

          leaf brief {
            type boolean;
            description
              "Brief mode. Does not include statistical data in result";
          }

          leaf timeout {
            type uint32 {
              range "0..3600";
            }
            description
              "Time in seconds before the lack of a reply invalidates a request";
          }

          leaf ttl {
            type uint32 {
              range "1..255";
            }
            description
              "Time to live (hops to until forced punt)";
          }
        }  // container request-options-parameters
      }

      output {
        container mpls-traceroute-response {
          description
            "MPLS traceroute Response";
          container request-options-parameters {
            description
              "Echo Request Options";
            leaf exp {
              type uint8 {
                range "0..7";
              }
              description "EXP Bits To Set";
            }

            leaf fec {
              type boolean;
              description
                "Force FEC TLV Checks";
            }

            leaf ddmap {
              type boolean;
              description
                "Use DDMAP (Default is DSMAP)";
            }

            leaf force-explicit-null {
              type boolean;
              description
                "Force an explicit null label to be added";
            }

            container packet-output {
              description
                "Packet output options";
              leaf interface-name {
                type string;
                description
                  "Outgoing interface for echo packet";
              }

              leaf next-hop {
                type inet:ipv4-address;
                description
                  "Outgoing next hop IP for echo packet";
              }
            }  // container packet-output

            container reply {
              description "Reply options";
              leaf dscp {
                type uint8 {
                  range "0..63";
                }
                description
                  "Set DSCP reply value 0-63 (decimal)";
              }

              leaf reply-mode {
                type request-reply-mode;
                description
                  "Echo Reply Mode";
              }
            }  // container reply

            leaf source {
              type inet:ipv4-address;
              description
                "Source IP address to use in the IP header (used as the return address for the reply)";
            }

            leaf destination {
              type inet:ipv4-address;
              description
                "Destination IP address (127.x.y.z)";
            }

            leaf brief {
              type boolean;
              description
                "Brief mode. Does not include statistical data in result";
            }

            leaf timeout {
              type uint32 {
                range "0..3600";
              }
              description
                "Time in seconds before the lack of a reply invalidates a request";
            }

            leaf ttl {
              type uint32 {
                range "1..255";
              }
              description
                "Time to live (hops to until forced punt)";
            }
          }  // container request-options-parameters

          container hops {
            description "Traceroute Hops";
            list hop {
              key "hop-index";
              description "Traceroute Hop";
              leaf hop-index {
                type uint64 {
                  range "1..2147483647";
                }
                description
                  "Index of the hop list";
              }

              leaf hop-origin-ip {
                type string;
                description
                  "Hop origin interface ip";
              }

              leaf hop-destination-ip {
                type string;
                description
                  "Hop destination interface ip";
              }

              leaf mtu {
                type string;
                description
                  "Maximum Transmission Unit";
              }

              container dsmap-label-stack {
                description
                  "Label Stack from the DSMAP received
                 in the Echo Response Payload.";
                list dsmap-label {
                  key "label";
                  description "DSMAP labels";
                  leaf label {
                    type uint32 {
                      range "16..1048575";
                    }
                    description
                      "DSMAP label";
                  }
                }  // list dsmap-label
              }  // container dsmap-label-stack

              leaf return-code {
                type uint8;
                description
                  "Return Code of the echo request";
              }

              leaf return-char {
                type string;
                description
                  "Return Char of the echo request";
              }

              leaf duration {
                type uint32;
                description
                  "Trip duration (msec)";
              }

              container ddmaps {
                description
                  "Downstream Detailed Mapping received";
                list ddmap {
                  key "ddmap-index";
                  description "DDMAP";
                  leaf ddmap-index {
                    type uint64 {
                      range "1..2147483647";
                    }
                    description
                      "Index of the hop list";
                  }

                  leaf ddmap-mtu {
                    type int16;
                    description
                      "MTU from the DDMAP received in
                     the Echo Response Payload";
                  }

                  leaf ddmap-downstream-address {
                    type inet:ipv4-address;
                    description
                      "Downstream Address from the DDMAP
                     received in the Echo Response Payload";
                  }

                  leaf ddmap-downstream-intf-index {
                    type int32 {
                      range "1..2147483647";
                    }
                    description
                      "Downstream Interface Address from the DDMAP
                     received in the Echo Response Payload.";
                  }

                  leaf ddmap-return-code {
                    type uint8;
                    description
                      "Return Code from the DDMAP received
                     in the Echo Response Payload.";
                  }

                  leaf ddmap-return-subcode {
                    type int16;
                    description
                      "Return Sub Code from the DDMAP
                     received in the Echo Response Payload.";
                  }

                  container ddmap-label-stack {
                    description
                      "Label Stack from the DDMAP received
                     in the Echo Response Payload.";
                    list ddmap-label {
                      key "label";
                      description
                        "ddmap labels";
                      leaf label {
                        type uint32 {
                          range
                            "16..1048575";
                        }
                        description
                          "ddmap label";
                      }
                    }  // list ddmap-label
                  }  // container ddmap-label-stack
                }  // list ddmap
              }  // container ddmaps
            }  // list hop
          }  // container hops
        }  // container mpls-traceroute-response
      }
    }  // rpc mpls-traceroute
  }  // module Cisco-IOS-XR-mpls-traceroute-act