module Cisco-IOS-XE-rpc {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XE-rpc";

    prefix ios-xe-rpc;

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

    include Cisco-IOS-XE-aaa-rpc;
    include Cisco-IOS-XE-arp-rpc;
    include Cisco-IOS-XE-bgp-rpc;
    include Cisco-IOS-XE-crypto-rpc;
    include Cisco-IOS-XE-multicast-rpc;
    include Cisco-IOS-XE-dhcp-rpc;
    include Cisco-IOS-XE-ospf-rpc;
    include Cisco-IOS-XE-platform-rpc;

    organization "Cisco Systems";

    contact "<mailto:cs-yang@cisco.com>";

    description
      "NED RPC YANG module for IOS
Copyright (c) 2016-2020 by Cisco Systems, Inc.
All rights reserved.";

    revision "2021-03-01" {
      description
        "- Added factory reset support";
    }

    revision "2020-11-01" {
      description
        "Added clear iox feature
corrected new keyword addition";
    }

    revision "2020-07-01" {
      description
        "Added multicast feature RPC";
    }

    revision "2020-03-01" {
      description
        "Added a container in monitor capture";
    }

    revision "2019-11-01" {
      description "Added new test RPC";
    }

    revision "2019-07-01" {
      description
        "Establish semantic version baseline";
    }

    revision "2018-11-25" {
      description
        "Exec command to send AMP file analysis apikey";
    }

    revision "2018-11-07" {
      description
        "Cleanup spelling errors in description statements";
    }

    revision "2018-11-06" {
      description
        "Add UTD database update EXEC command";
    }

    revision "2018-10-29" {
      description
        "Added range-string for debug ipsec command";
    }

    revision "2018-10-12" {
      description
        "Added crypto pki debug and exec commands";
    }

    revision "2018-10-02" {
      description
        "Add unmount command in existing hw-module chain";
    }

    revision "2018-10-01" {
      description
        "Add IPSEC no debug exec commands";
    }

    revision "2018-09-20" {
      description
        "Add IPSEC debug exec commands";
    }

    revision "2018-08-17" {
      description
        "Added cts credential * and clear cts * commands";
    }

    revision "2018-08-05" {
      description
        "Add License Install Commands";
    }

    revision "2018-08-01" {
      description "Add UTD clear commands";
    }

    revision "2018-07-30" {
      description "Add hw-module commands";
    }

    revision "2018-06-18" {
      description
        "Update UTD signature update EXEC command to include local file support";
    }

    revision "2018-05-21" {
      description
        "Add Umbrella clear commands";
    }

    revision "2018-04-18" {
      description "Add ZBFW clear commands";
    }

    revision "2018-03-14" {
      description
        "Add UTD signature update EXEC command";
    }

    revision "2017-12-18" {
      description
        "Add GIR start maintenance and stop maintenance EXEC commands";
    }

    revision "2017-12-06" {
      description
        "Add Viptela clear aaa local user lockout username <> command";
    }

    revision "2017-11-27" {
      description
        "Add Viptela clear and release commands";
    }

    revision "2017-11-21" {
      description "Clear flow commands";
    }

    revision "2017-11-14" {
      description
        "Add app-hosting and guestshell EXEC commands";
    }

    revision "2017-11-04" {
      description "Add reason to reload";
    }

    revision "2017-10-12" {
      description
        "Added more nodes to the license RPC";
    }

    revision "2017-10-10" {
      description
        "Add copy and delete EXEC commands";
    }

    revision "2017-09-21" {
      description
        "Add virtual-service EXEC commands";
    }

    revision "2017-08-28" {
      description
        "Added the force option to the reload RPC";
    }

    revision "2017-07-13" {
      description "Added service sd-avc CLI";
    }

    revision "2017-02-07" {
      description "Initial revision";
    }

    cisco-semver:module-version "3.2.0";
    cisco-semver:module-version "3.1.0";
    cisco-semver:module-version "3.0.0";
    cisco-semver:module-version "2.1.0";
    cisco-semver:module-version "2.0.0";
    cisco-semver:module-version "1.0.0";

    grouping cisco-xe-rpc-output {
      description
        "Used to return output from RPCs";
      leaf result {
        type string;
        description
          "Output returned by the network element";
      }
    }  // grouping cisco-xe-rpc-output

    rpc default {
      description
        "Set a command to its defaults";
      input {
        choice default-choice {
          mandatory true;
          leaf interface {
            type string {
              pattern '[A-Za-z]([\w/.-]+)';
            }
            description
              "Select an interface to configure";
          }
        }  // choice default-choice
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc default

    rpc clear {
      description "Clear";
      input {
        choice clear-choice {
          mandatory true;
          leaf interface {
            type string {
              pattern '[A-Za-z]([\w/.-]+)';
            }
            description
              "Select an interface to clear";
          }
          leaf count {
            type string {
              pattern '[A-Za-z]([\w/.-]+)';
            }
            description
              "Select an interface to clear";
          }
          container ip {
            choice ip-protocol {
              case bgp-case {
                uses clear-choice-ip-case-ip-protocol-bgp-case-grouping;
              }  // case bgp-case

              case dhcp-case {
                uses clear-choice-ip-case-ip-protocol-dhcp-case-grouping;
              }  // case dhcp-case

              case ospf-case {
                uses clear-choice-ip-case-ip-protocol-ospf-case-grouping;
              }  // case ospf-case
            }  // choice ip-protocol
          }  // container ip

          case arp-cache-case {
            uses clear-choice-arp-cache-case-grouping;
          }  // case arp-cache-case

          case aaa-case {
            uses clear-choice-aaa-case-grouping;
          }  // case aaa-case

          case platform-case {
            uses clear-choice-platform-case-grouping;
          }  // case platform-case
          leaf iox {
            type empty;
            description
              "Clear all IOX data to the default, initial IOX state";
          }
        }  // choice clear-choice
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc clear

    rpc crypto {
      description
        "Encryption related commands";
      input {
        uses crypto-input-grouping;
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc crypto

    rpc release {
      description "Release a resource";
      input {
        leaf dhcp {
          type string;
          description
            "Release a dhcp lease (an interface)";
        }
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc release

    rpc reload {
      description
        "Halt and perform a cold restart";
      input {
        leaf force {
          type boolean;
          description
            "Force a restart even if there is unsaved config";
        }

        leaf reason {
          type string;
          description "Reload reason";
        }
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc reload

    rpc factory-reset {
      description
        "Perform a factory reset of the device";
      input {
        container all {
          presence "true";
          description
            "Perform a factory reset of the device. This will
restore the device to the factory setting and is an
irreversible operation";
        }  // container all

        leaf keep-licensing-info {
          type empty;
          description
            "Perform a factory reset of the device. This will
keep some licensing specific information";
        }
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc factory-reset

    rpc license {
      input {
        choice license-command-choice {
          container smart {
            choice smart-choice {
              container save {
                choice save-case {
                  container usage {
                    choice usage-case {
                      container all {
                        leaf file {
                          type string {
                            pattern
                              '(((bootflash:)|(flash:)|(ftp:)|(http:)|(https:)|(nvram:)|(param:)|(scp:)|(syslog)|(system:)|(tftp:)|(tmpsys:)).*)';
                          }
                          description
                            "The local or network file path to write the RUM
reports to.";
                        }
                      }  // container all
                      container unreported {
                        leaf file {
                          type string {
                            pattern
                              '(((bootflash:)|(flash:)|(ftp:)|(http:)|(https:)|(nvram:)|(param:)|(scp:)|(syslog)|(system:)|(tftp:)|(tmpsys:)).*)';
                          }
                          description
                            "The local or network file path to write the RUM
reports to.";
                        }
                      }  // container unreported
                    }  // choice usage-case

                    leaf days {
                      type uint32 {
                        range "1..1000000";
                      }
                      description
                        "Save RUM reports that include measurements in the
specified number of days";
                    }

                    leaf file {
                      type string {
                        pattern
                          '(((bootflash:)|(flash:)|(ftp:)|(http:)|(https:)|(nvram:)|(param:)|(scp:)|(syslog)|(system:)|(tftp:)|(tmpsys:)).*)';
                      }
                      description
                        "The local or network file path to write the RUM
reports to.";
                    }
                  }  // container usage
                  leaf trust-request {
                    type string {
                      pattern
                        '(((bootflash:)|(flash:)|(ftp:)|(http:)|(https:)|(nvram:)|(param:)|(scp:)|(syslog)|(system:)|(tftp:)|(tmpsys:)).*)';
                    }
                    description
                      "The local or network file path to write
the trust request to.";
                  }
                }  // choice save-case
              }  // container save
              container authorization {
                choice authorization-choice {
                  container request {
                    leaf add {
                      type string;
                      description
                        "The feature name to get the authorization code for
The smart agent will look this up in it's mapping
table and get the proper entitlement tag for it.";
                    }

                    leaf replace {
                      type string;
                      description
                        "The feature name to get the authorization code for
The smart agent will look this up in it's mapping
table and get the proper entitlement tag for it.";
                    }

                    leaf all {
                      type empty;
                      description
                        "Applies to an HA configuration.";
                    }

                    leaf local {
                      type empty;
                      description
                        "The authorization request will only be for
the active device.";
                    }
                  }  // container request
                  container return {
                    leaf all {
                      type empty;
                      description
                        "Applies to an HA configuration.";
                    }

                    leaf local {
                      type empty;
                      description
                        "The authorization request will only be for
the active device.";
                    }

                    leaf offline {
                      type string;
                      description
                        "Returns a currently installed authorization
code offline.";
                    }

                    leaf online {
                      type empty;
                      description
                        "Returns a currently installed authorization
code online.";
                    }
                  }  // container return
                }  // choice authorization-choice
              }  // container authorization
              leaf import {
                type string;
                mandatory true;
                description
                  "The local or network file path to read from";
              }
              container trust {
                leaf idtoken {
                  type string;
                  mandatory true;
                  description
                    "The ID token used to establish trust.";
                }

                leaf all {
                  type empty;
                  description
                    "If true perform the operation for all devices
in an HA configuration.";
                }

                leaf local {
                  type empty;
                  description
                    "If false then only establish
trust for the active device.";
                }

                leaf force {
                  type empty;
                  description
                    "Force the trust establishment even if the product
instance has already establish trust with the Cisco
Smart Software Management.";
                }
              }  // container trust
              container register {
                leaf idtoken {
                  type string;
                  mandatory true;
                }

                leaf force {
                  type empty;
                  description
                    "Forcefully register";
                }
              }  // container register
              leaf deregister {
                type empty;
              }
              container renew {
                choice renew-choice {
                  mandatory true;
                  leaf ID {
                    type empty;
                  }
                  leaf auth {
                    type empty;
                  }
                }  // choice renew-choice
              }  // container renew
            }  // choice smart-choice
          }  // container smart
          leaf install {
            type string {
              pattern
                '(((bootflash:)|(flash:)|(ftp:)|(http:)|(https:)|(nvram:)|(param:)|(scp:)|(syslog)|(system:)|(tftp:)|(tmpsys:)).*)';
            }
            description
              "Install license information";
          }
          leaf clear {
            type string;
            description
              "Clear license information. Feature name to clear";
          }
        }  // choice license-command-choice
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc license

    rpc service {
      description
        "IOS integrated service enablement";
      input {
        choice services-choice {
          container waas {
            description "WAAS service";
            container wcm {
              description
                "Configure WAAS Central Manager (WCM)";
              choice wcm-choices {
                container ip {
                  description "ipv4";
                  leaf address {
                    type inet:ipv4-address;
                  }
                }  // container ip
                container ipv6 {
                  description "ipv6 address";
                  leaf address {
                    type inet:ipv6-address;
                  }
                }  // container ipv6
              }  // choice wcm-choices
            }  // container wcm
          }  // container waas
          container sd-avc {
            description
              "SD-AVC service management";
            choice sd-avc-choice {
              mandatory true;
              leaf activate {
                type empty;
              }
              container configure {
                container gateway {
                  leaf interface {
                    type string;
                  }

                  leaf service-ip {
                    type inet:ipv4-address;
                  }

                  leaf activate {
                    type empty;
                  }
                }  // container gateway
              }  // container configure
              leaf connect {
                type empty;
              }
              leaf help {
                type empty;
              }
              leaf deactivate {
                type empty;
              }
              container install {
                leaf package {
                  type string;
                }
              }  // container install
              leaf status {
                type empty;
              }
              leaf unconfigure {
                type empty;
              }
              leaf uninstall {
                type empty;
              }
              container upgrade {
                leaf package {
                  type string;
                }
              }  // container upgrade
            }  // choice sd-avc-choice
          }  // container sd-avc
        }  // choice services-choice
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc service

    rpc virtual-service {
      description
        "Virtual-service management";
      input {
        choice operation {
          mandatory true;
          container install {
            leaf name {
              type string;
            }

            leaf package {
              type string;
            }

            leaf media {
              type string;
            }
          }  // container install
          container uninstall {
            leaf name {
              type string;
            }
          }  // container uninstall
          container upgrade {
            leaf name {
              type string;
            }

            leaf package {
              type string;
            }
          }  // container upgrade
          container move {
            leaf name {
              type string;
              mandatory true;
            }

            choice file-choice {
              mandatory true;
              container core {
                leaf to {
                  type string {
                    pattern
                      '(((bootflash:)|(flash:)|(harddisk:)).*)';
                  }
                }
              }  // container core
              container log {
                leaf to {
                  type string {
                    pattern
                      '(((bootflash:)|(flash:)|(harddisk:)).*)';
                  }
                }
              }  // container log
            }  // choice file-choice
          }  // container move
        }  // choice operation
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc virtual-service

    rpc copy {
      description
        "Copy from one file to another";
      input {
        leaf source-drop-node-name {
          type string {
            pattern
              '((((bootflash:)|(harddisk:)|(flash:)|(nvram:)|(ftp:)|(http:)|(https:)|(scp:)|(tftp:)).*)|((running-config)|(startup-config)))';
          }
          mandatory true;
        }

        leaf destination-drop-node-name {
          type string {
            pattern
              '((((bootflash:)|(harddisk:)|(flash:)|(nvram:)|(ftp:)|(http:)|(https:)|(scp:)|(tftp:)).*)|((running-config)|(startup-config)))';
          }
          mandatory true;
        }
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc copy

    rpc delete {
      description "Delete a file";
      input {
        leaf filename-drop-node-name {
          type string {
            pattern
              '(((bootflash:)|(harddisk:)|(flash:)|(nvram:)).*)';
          }
          mandatory true;
        }
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc delete

    rpc app-hosting {
      description "App-hosting management";
      input {
        choice lifecycle {
          mandatory true;
          container install {
            leaf appid {
              type string;
            }

            leaf package {
              type string;
            }
          }  // container install
          container uninstall {
            leaf appid {
              type string;
            }
          }  // container uninstall
          container activate {
            leaf appid {
              type string;
            }
          }  // container activate
          container deactivate {
            leaf appid {
              type string;
            }
          }  // container deactivate
          container start {
            leaf appid {
              type string;
            }
          }  // container start
          container stop {
            leaf appid {
              type string;
            }
          }  // container stop
          container upgrade {
            leaf appid {
              type string;
            }

            leaf package {
              type string;
            }
          }  // container upgrade
          container verification {
            leaf enable {
              type empty;
            }

            leaf disable {
              type empty;
            }
          }  // container verification
          container move {
            choice type-choice {
              mandatory true;
              case appid-case {
                leaf appid {
                  type string;
                  mandatory true;
                }

                choice file-choice {
                  mandatory true;
                  container core {
                    leaf to {
                      type string {
                        pattern
                          '(((bootflash:)|(flash:)|(harddisk:)).*)';
                      }
                    }
                  }  // container core
                  container log {
                    leaf to {
                      type string {
                        pattern
                          '(((bootflash:)|(flash:)|(harddisk:)).*)';
                      }
                    }
                  }  // container log
                }  // choice file-choice
              }  // case appid-case
              container system {
                container techsupport {
                  leaf to {
                    type string {
                      pattern
                        '(((bootflash:)|(flash:)|(harddisk:)).*)';
                    }
                  }
                }  // container techsupport
              }  // container system
            }  // choice type-choice
          }  // container move
        }  // choice lifecycle
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc app-hosting

    rpc guestshell {
      description
        "guestshell managementshell";
      input {
        choice action {
          mandatory true;
          leaf destroy {
            type empty;
            description "Destroy guestshell";
          }
          leaf disable {
            type empty;
            description "Disable guestshell";
          }
          leaf enable {
            type empty;
            description "Enable guestshell";
          }
        }  // choice action
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc guestshell

    rpc start {
      description "Start system operations";
      input {
        leaf maintenance {
          type empty;
          description
            "GIR start maintenance mode";
        }
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc start

    rpc stop {
      description "Stop system operations";
      input {
        leaf maintenance {
          type empty;
          description
            "GIR stop maintenance mode";
        }
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc stop

    rpc hw-module {
      description
        "Control of individual components in the system";
      input {
        container switch {
          description "Switch in the system";
          leaf switch-number-drop-node-name {
            type uint8 {
              range "1..8";
            }
            description
              "Switch number in the Stack (Refer to show switch CLI)";
          }

          container usbflash1 {
            description "USB SSD";
            choice umount-sec {
              mandatory true;
              leaf unmount {
                type empty;
                description
                  "unmount on usbflash1";
              }
              container security {
                description
                  "Security on usbflash1";
                choice security-choice {
                  mandatory true;
                  container enable {
                    presence "true";
                    description
                      "Enable security on usbflash1";
                    leaf password {
                      type string;
                      description
                        "Enter password for enabling security on usbflash1";
                    }
                  }  // container enable
                  container disable {
                    presence "true";
                    description
                      "Disable security on usbflash1";
                    leaf password {
                      type string;
                      description
                        "Enter password for Disabling security on usbflash1";
                    }
                  }  // container disable
                  container unlock {
                    presence "true";
                    description
                      "Unlock security on usbflash1";
                    leaf password {
                      type string;
                      description
                        "Enter password for unlock security on usbflash1";
                    }
                  }  // container unlock
                }  // choice security-choice
              }  // container security
            }  // choice umount-sec
          }  // container usbflash1
        }  // container switch
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc hw-module

    rpc debug {
      description "Debug";
      input {
        choice debug-choice {
          mandatory true;
          case crypto-case {
            uses debug-input-crypto-grouping;
          }  // case crypto-case

          case platform-case {
            uses debug-choice-platform-case-grouping;
          }  // case platform-case
        }  // choice debug-choice
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc debug

    rpc monitor {
      description "monitor";
      input {
        leaf capture {
          type string;
          description "Capture session";
        }

        leaf match {
          type string;
          description
            "Describe filters inline";
        }

        leaf interface {
          type string;
          description "Interface";
        }

        choice capture-direction-choice {
          leaf both {
            type empty;
          }
          leaf in {
            type empty;
          }
          leaf out {
            type empty;
          }
        }  // choice capture-direction-choice

        container buffer {
          description "Buffer options";
          leaf size {
            type uint8 {
              range "1..100";
            }
            description
              "Size of buffer in MB";
          }

          leaf circular {
            type empty;
            description "circular buffer";
          }
        }  // container buffer

        container limit {
          description
            "Limit Packets Captured";
          leaf duration {
            type uint32 {
              range "1..1000000";
            }
            description
              "Limit total duration of capture in seconds";
          }

          leaf every {
            type uint32 {
              range "2..100000";
            }
            description
              "Limit capture to one in every nth packet";
          }

          leaf packet-len {
            type uint16 {
              range "64..9500";
            }
            description
              "Limit the packet length to capture";
          }

          leaf packets {
            type uint32 {
              range "1..100000";
            }
            description
              "Limit number of packets to capture";
          }

          leaf pps {
            type uint32 {
              range "1..1000000";
            }
            description
              "Limit number of packets per second to capture";
          }
        }  // container limit

        choice capture-command-choice {
          leaf start {
            type empty;
            description
              "Enable session capture points";
          }
          leaf stop {
            type empty;
            description
              "Disable session capture points";
          }
          leaf stop_export {
            type empty;
            description
              "Export session capture buffer";
          }
        }  // choice capture-command-choice
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc monitor

    rpc pnpa {
      description "Plug and play command";
      input {
        container service {
          description "Service Name";
          choice service-choice {
            container wakeup {
              description "Wake up Profile";
              leaf profile-drop-node-name {
                type string;
                description "Profile name";
              }
            }  // container wakeup
            leaf reset {
              type empty;
              description "Reset PnP config";
            }
          }  // choice service-choice
        }  // container service
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc pnpa

    rpc test {
      description "test exec command";
      input {
        choice test-feature;
      }

      output {
        uses cisco-xe-rpc-output;
      }
    }  // rpc test
  }  // module Cisco-IOS-XE-rpc