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

    yang-version 1;

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

    prefix mpls-ping-act;

    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    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 ping 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 ping";
    }

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

    revision "2021-01-26" {
      description
        "Changed Pad leaf to Hexadecimal String";
    }

    revision "2020-06-13" {
      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 "no-reply" {
          value 1;
          description "Reply Mode No Reply";
        }
        enum "router-alert" {
          value 2;
          description
            "Reply Mode Router Alert";
        }
      }
      description "Reply mode";
    }

    rpc mpls-ping {
      description "Send echo messages";
      input {
        choice ping-type {
          mandatory true;
          description "Specify ping type";
          container mpls {
            description "MPLS ping";
            choice mpls-subtype {
              mandatory true;
              description
                "Ping MPLS subtype";
              container ipv4 {
                description
                  "Ping mpls IPv4 address";
                leaf ip {
                  type inet:ipv4-address;
                  mandatory true;
                  description
                    "destination X.X.X.X of mpls ping";
                }

                choice subnet {
                  mandatory true;
                  description
                    "The subnet to 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 "MPLS-TE ping";
                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 {
                  default
                    "te-lsp-option-active";
                  description
                    "Specify which LSP to use";
                  leaf active-lsp {
                    type boolean;
                    default "true";
                    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 "Ping sr-mpls";
            choice sr-target {
              description
                "Ping sr-mpls target type";
              container ipv4 {
                description
                  "Ping sr-mpls IPv4 Prefix SID";
                leaf ip {
                  type inet:ipv4-address;
                  mandatory true;
                  description
                    "SR LSP Egress IP";
                }

                choice subnet {
                  mandatory true;
                  description
                    "The subnet to 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
                  "Ping 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
                  "Ping 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";
                    }
                    mandatory true;
                    description
                      "SR Policy Binding SID";
                  }
                  leaf name {
                    type string;
                    mandatory true;
                    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
          container pseudowire {
            description
              "Ping mpls pseudowire";
            choice pw-type {
              description
                "Ping mpls pseudowire type";
              container fec-128 {
                description "FEC 128";
                leaf remote-pe-addr {
                  type inet:ipv4-address;
                  mandatory true;
                  description
                    "PW LSP Egress IPv4 Identifier";
                }

                leaf pwid {
                  type uint32 {
                    range "1..4294967295";
                  }
                  mandatory true;
                  description
                    "Pseudowire Identifier";
                }

                leaf deprecated-fec128 {
                  type boolean;
                  description
                    "Force the use of the Deprecated FEC128 described in RFC4379";
                }

                container force-control-channel {
                  description
                    "Force the use of a VCCV control channel";
                  choice force-control-channel-fec128 {
                    description
                      "Force control channel type";
                    leaf control-word {
                      type boolean;
                      description
                        "Force Control Word";
                    }
                    leaf ra-label {
                      type boolean;
                      description "RA Label";
                    }
                    leaf ttl-expiry {
                      type boolean;
                      description
                        "VC Label TTL expiry";
                    }
                  }  // choice force-control-channel-fec128
                }  // container force-control-channel
              }  // container fec-128
              container multisegment {
                description
                  "Ping mpls pseudowire multisegment";
                leaf remote-pe-addr {
                  type inet:ipv4-address;
                  mandatory true;
                  description
                    "PW LSP Egress IPv4 Identifier";
                }

                leaf pwid {
                  type uint32 {
                    range "1..4294967295";
                  }
                  mandatory true;
                  description
                    "Pseudowire Identifier";
                }

                leaf deprecated-fec128 {
                  type boolean;
                  description
                    "Force the use of the Deprecated FEC128 described in RFC4379";
                }

                container destination-fec {
                  description
                    "Destination FEC <Sender IP Address> <Remote IP Address> <PW ID>";
                  leaf sender-ip {
                    type inet:ipv4-address;
                    mandatory true;
                    description
                      "Sender address for Destination FEC";
                  }

                  leaf remote-ip {
                    type inet:ipv4-address;
                    mandatory true;
                    description
                      "Remote address for Destination FEC";
                  }

                  leaf destination-fec-pw-id {
                    type uint32;
                    mandatory true;
                    description
                      "Destination FEC Pseudowire ID";
                  }
                }  // container destination-fec

                container force-control-channel {
                  description
                    "Force the use of a VCCV control channel";
                  choice force-control-channel-mspw {
                    description
                      "Force Control Channel type";
                    leaf control-word {
                      type boolean;
                      description
                        "Force Control Word";
                    }
                    leaf ttl-expiry {
                      type boolean;
                      description
                        "VC Label TTL expiry";
                    }
                  }  // choice force-control-channel-mspw
                }  // container force-control-channel

                leaf segment-count {
                  type uint32 {
                    range "1..255";
                  }
                  description
                    "Segement Count for Destination FEC";
                }
              }  // container multisegment
              container fec-129 {
                description "FEC 129";
                choice fec-129-type {
                  description
                    "FEC 129 Attachement Identifier Type";
                  container aii-type1 {
                    description
                      "Type 1 Attachment Identifier";
                    container vpls-id {
                      description
                        "VPLS ID of the bridge domain";
                      choice vpls-id-type {
                        description
                          "VPLS ID type";
                        container byte-as {
                          description
                            "Two Byte AS number";
                          leaf byte {
                            type uint16 {
                              range
                                "1..65535";
                            }
                            mandatory true;
                            description
                              "VPLS Byte ID";
                          }

                          leaf space {
                            type uint32;
                            mandatory true;
                            description
                              "Namespace";
                          }
                        }  // container byte-as
                        container ip-prefix-as {
                          description
                            "IP address";
                          leaf ip-prefix {
                            type inet:ipv4-address;
                            mandatory true;
                            description
                              "VPLS IP Prefix ID";
                          }

                          leaf space {
                            type uint32 {
                              range
                                "0..32767";
                            }
                            mandatory true;
                            description
                              "Namespace";
                          }
                        }  // container ip-prefix-as
                      }  // choice vpls-id-type
                    }  // container vpls-id

                    leaf target {
                      type inet:ipv4-address;
                      mandatory true;
                      description
                        "L2VPN router-id of the target";
                    }
                  }  // container aii-type1
                  container aii-type2 {
                    description
                      "Type 2 Attachment Identifier";
                    leaf global-id {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      mandatory true;
                      description
                        "Global ID of the pseudowire";
                    }

                    leaf target {
                      type inet:ipv4-address;
                      mandatory true;
                      description
                        "Target end address of the pseudowire";
                    }

                    leaf circuit-id {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      mandatory true;
                      description
                        "Attachment Circuit ID";
                    }
                  }  // container aii-type2
                }  // choice fec-129-type

                container force-control-channel {
                  description
                    "Force the use of a VCCV control channel";
                  choice force-control-channel-fec129 {
                    description
                      "Force Control Channel type";
                    leaf control-word {
                      type boolean;
                      description
                        "Force Control Word";
                    }
                    leaf ra-label {
                      type boolean;
                      description "RA Label";
                    }
                    leaf ttl-expiry {
                      type boolean;
                      description
                        "VC Label TTL expiry";
                    }
                  }  // choice force-control-channel-fec129
                }  // container force-control-channel
              }  // container fec-129
            }  // choice pw-type
          }  // container pseudowire
        }  // choice ping-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 interval {
            type uint32 {
              range "0..3600000";
            }
            description
              "Time between echo requests in ms";
          }

          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 xr:Interface-name;
              description
                "Outgoing interface with form <Interface>R/S/I/P for echo packet";
            }

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

          leaf pad {
            type xr:Hex-integer-16;
            description "HEX Padding 0-ffff";
          }

          leaf repeat {
            type uint32 {
              range "1..2147483647";
            }
            default "5";
            description
              "Number of echo requests to send";
          }

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

            leaf pad-tlv {
              type boolean;
              description
                "Enable PAD TLV for the request";
            }
          }  // container reply

          leaf size {
            type uint16 {
              range "100..17986";
            }
            description
              "Define Packet Size for the request";
          }

          leaf source {
            type inet:ipv4-address;
            description
              "Source IP address to use in the IP header";
          }

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

          container sweep {
            description
              "Echo request sweep options";
            leaf minimum {
              type uint32 {
                range "100..17986";
              }
              mandatory true;
              description "Sweep min value";
            }

            leaf maximum {
              type uint32 {
                range "100..17986";
              }
              mandatory true;
              description "Sweep max value";
            }

            leaf increment {
              type uint32 {
                range "1..8993";
              }
              mandatory true;
              description "Sweep incr value";
            }
          }  // container sweep

          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-ping-response {
          description "MPLS ping 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 interval {
              type uint32 {
                range "0..3600000";
              }
              description
                "Time between echo requests in ms";
            }

            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 xr:Interface-name;
                description
                  "Outgoing interface with form <Interface>R/S/I/P for echo packet";
              }

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

            leaf pad {
              type xr:Hex-integer-16;
              description
                "HEX Padding 0-ffff";
            }

            leaf repeat {
              type uint32 {
                range "1..2147483647";
              }
              default "5";
              description
                "Number of echo requests to send";
            }

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

              leaf pad-tlv {
                type boolean;
                description
                  "Enable PAD TLV for the request";
              }
            }  // container reply

            leaf size {
              type uint16 {
                range "100..17986";
              }
              description
                "Define Packet Size for the request";
            }

            leaf source {
              type inet:ipv4-address;
              description
                "Source IP address to use in the IP header";
            }

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

            container sweep {
              description
                "Echo request sweep options";
              leaf minimum {
                type uint32 {
                  range "100..17986";
                }
                mandatory true;
                description
                  "Sweep min value";
              }

              leaf maximum {
                type uint32 {
                  range "100..17986";
                }
                mandatory true;
                description
                  "Sweep max value";
              }

              leaf increment {
                type uint32 {
                  range "1..8993";
                }
                mandatory true;
                description
                  "Sweep incr value";
              }
            }  // container sweep

            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 replies {
            description "MPLS ping replies";
            list reply {
              key "reply-index";
              description "MPLS ping reply";
              leaf reply-index {
                type uint64 {
                  range "1..2147483647";
                }
                description
                  "Index of the reply list";
              }

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

              leaf reply-addr {
                type string;
                description "Reply Address";
              }

              leaf size {
                type uint32;
                description "Packet size";
              }
            }  // list reply
          }  // container replies

          container statistics {
            description
              "Statistics Response";
            leaf tmin {
              type uint32;
              description
                "Minimum Trip Duration";
            }

            leaf tmax {
              type uint32;
              description
                "Maximum Trip Duration";
            }

            leaf tavg {
              type uint32;
              description
                "Average Trip Duration";
            }

            leaf hits {
              type uint32;
              description
                "Number of successful ping requests sent";
            }

            leaf tries {
              type uint32;
              description
                "Number of ping requests sent";
            }
          }  // container statistics
        }  // container mpls-ping-response
      }
    }  // rpc mpls-ping
  }  // module Cisco-IOS-XR-mpls-ping-act