module Cisco-IOS-XR-spirit-install-act {

    yang-version 1;

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

    prefix spirit-install-act;

    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 action package configuration.
     
     Copyright (c) 2016-2019 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2019-12-03" {
      description
        "Prefix changed from install-act to spirit-install-act";
    }

    revision "2019-10-01" {
      description
        "Made changes to be RFC6087 compliant";
    }

    revision "2019-04-05" {
      description
        "Establish semantic version baseline.";
    }

    revision "2018-09-10" {
      description
        "Added output container with op-id and Error as leaf node";
    }

    revision "2017-10-23" {
      description
        "Yang support for all install action cli's";
    }

    revision "2017-07-27" {
      description "IOS XR 6.4.1 revision.";
    }

    semver:module-version "1.1.0";
    semver:module-version "1.1.0";
    semver:module-version "1.0.0";

    rpc install-add {
      description
        "Cli-command install add source";
      input {
        leaf packagepath {
          type string;
          description
            "install add source Package path";
        }

        leaf-list packagename {
          type string;
          max-elements 31;
          description
            "install add source Package name";
        }
      }

      output {
        leaf op-id {
          type string;
          description
            "operation id of the triggered action";
        }

        leaf Error {
          type string;
          description
            "case when op-id is not triggered";
        }
      }
    }  // rpc install-add

    rpc install-commit {
      description
        "Cli-command install commit";
      input {
        leaf sdr {
          type empty;
          description
            "commit packages in the system";
        }
      }

      output {
        leaf op-id {
          type string;
          description
            "operation id of the triggered action";
        }

        leaf Error {
          type string;
          description
            "case when op-id is not triggered";
        }
      }
    }  // rpc install-commit

    rpc install-remove {
      description "Cli-command remove";
      input {
        container packages {
          description
            "install remove packages";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install remove package name";
          }
        }  // container packages

        container ids {
          description "install remove ids";
          leaf-list id-no {
            type string;
            max-elements 32;
            description
              "install remove id number";
          }
        }  // container ids

        leaf inactive {
          type empty;
          description
            "Remove inactive packages from XR repo";
        }

        leaf inactiveall {
          type empty;
          description
            "Remove inactive packages from Host,Sysadmin and XR repo";
        }
      }

      output {
        leaf op-id {
          type string;
          description
            "operation id of the triggered action";
        }

        leaf Error {
          type string;
          description
            "case when op-id is not triggered";
        }
      }
    }  // rpc install-remove

    rpc install-prepare {
      description "Cli-command prepare";
      input {
        container packages {
          description
            "install prepare packages";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install prepare package name";
          }
        }  // container packages

        container ids {
          description "install prepare ids";
          leaf-list id-no {
            type string;
            max-elements 32;
            description
              "install prepare id number";
          }
        }  // container ids

        leaf clean {
          type empty;
          description
            "Clean the prepared packages";
        }

        container prepare-force {
          description
            "install prepare force";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install prepare force package name";
          }

          leaf-list ids {
            type string;
            max-elements 32;
            description
              "install prepare force ids";
          }
        }  // container prepare-force
      }

      output {
        leaf op-id {
          type string;
          description
            "operation id of the triggered action";
        }

        leaf Error {
          type string;
          description
            "case when op-id is not triggered";
        }
      }
    }  // rpc install-prepare

    rpc install-activate {
      description "Cli-command activate";
      input {
        container warm {
          description "install warm";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install warm package name";
          }

          leaf-list ids {
            type string;
            max-elements 32;
            description "install warm ids";
          }
        }  // container warm

        container warm-force {
          description "install warm force";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install warm force package name";
          }

          leaf-list ids {
            type string;
            max-elements 32;
            description
              "install warm force ids";
          }
        }  // container warm-force

        container warm-replace {
          description "install warm replace";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install warm replace package name";
          }

          leaf-list ids {
            type string;
            max-elements 32;
            description
              "install warm replace ids";
          }
        }  // container warm-replace

        container warm-replace-force {
          description
            "install warm replace force";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install warm replace force package name";
          }

          leaf-list ids {
            type string;
            max-elements 32;
            description
              "install warm replace force ids";
          }
        }  // container warm-replace-force

        container reload {
          description "install reload";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install reload package name";
          }

          leaf-list ids {
            type string;
            max-elements 32;
            description "install reload ids";
          }
        }  // container reload

        container reload-force {
          description "install reload force";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install reload force package name";
          }

          leaf-list ids {
            type string;
            max-elements 32;
            description
              "install reload force ids";
          }
        }  // container reload-force

        container replace {
          description "install replace";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install replace package name";
          }

          leaf-list ids {
            type string;
            max-elements 32;
            description
              "install replace ids";
          }
        }  // container replace

        container replace-force {
          description
            "install replace force";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install replace force package name";
          }

          leaf-list ids {
            type string;
            max-elements 32;
            description
              "install replace force ids";
          }
        }  // container replace-force

        container activate-force {
          description
            "install activate force";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install activate force package name";
          }

          leaf-list ids {
            type string;
            max-elements 32;
            description
              "install activate force ids";
          }
        }  // container activate-force

        container packages {
          description
            "install activate packages";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install activate package name";
          }
        }  // container packages

        container ids {
          description "install activate ids";
          leaf-list id-no {
            type string;
            max-elements 32;
            description
              "install activate id number";
          }
        }  // container ids

        leaf activate_prepared_pkg {
          type empty;
          description
            "Activate the prepared package";
        }

        leaf force {
          type empty;
          description
            "Activate the prepared package with force option";
        }

        leaf activate-reload {
          type empty;
          description
            "Activate the prepared package with reload option";
        }

        leaf activate-reload-force {
          type empty;
          description
            "Activate the prepared package with reload force option";
        }

        leaf activate_warm_prepared_pkg {
          type empty;
          description
            "Activate the prepared package with warm option";
        }

        leaf activate_warm_force_prepared_pkg {
          type empty;
          description
            "Activate the prepared package with warm force option";
        }

        leaf activate_warm_replace_prepared_pkg {
          type empty;
          description
            "Activate the prepared package with warm replace option";
        }

        leaf activate_warm_force_replace_prepared_pkg {
          type empty;
          description
            "Activate the prepared package with warm force replace option";
        }
      }

      output {
        leaf op-id {
          type string;
          description
            "operation id of the triggered action";
        }

        leaf Error {
          type string;
          description
            "case when op-id is not triggered";
        }
      }
    }  // rpc install-activate

    rpc install-deactivate {
      description "Cli-command deactivate";
      input {
        container reload {
          description
            "install deactivate reload";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install deactivate reload package name";
          }

          leaf-list ids {
            type string;
            max-elements 32;
            description
              "install deactivate reload ids";
          }
        }  // container reload

        container packages {
          description
            "install deactivate packages";
          leaf-list packagename {
            type string;
            max-elements 32;
            description
              "install deactivate package name";
          }
        }  // container packages

        container ids {
          description
            "install deactivate ids";
          leaf-list id-no {
            type string;
            max-elements 32;
            description
              "install deactivate id number";
          }
        }  // container ids

        leaf superseded {
          type empty;
          description
            "Deactivate all superseded packages";
        }
      }

      output {
        leaf op-id {
          type string;
          description
            "operation id of the triggered action";
        }

        leaf Error {
          type string;
          description
            "case when op-id is not triggered";
        }
      }
    }  // rpc install-deactivate

    rpc install-extract {
      description "Cli-command extract";
      input {
        container packages {
          description
            "install extract packages";
          leaf-list packagename {
            type string;
            max-elements 1;
            description
              "install extract package name";
          }
        }  // container packages
      }

      output {
        leaf op-id {
          type string;
          description
            "operation id of the triggered action";
        }

        leaf Error {
          type string;
          description
            "case when op-id is not triggered";
        }
      }
    }  // rpc install-extract

    rpc install-verify {
      description
        "Cli-command install verify packages";
      input {
        leaf-list location {
          type string;
          max-elements 32;
          description
            "install verify packages location";
        }
      }

      output {
        leaf op-id {
          type string;
          description
            "operation id of the triggered action";
        }

        leaf Error {
          type string;
          description
            "case when op-id is not triggered";
        }
      }
    }  // rpc install-verify

    rpc install-update {
      description
        "Cli-command install update";
      input {
        leaf packagepath {
          type string;
          description
            "install update package path";
        }

        leaf-list packagename {
          type string;
          max-elements 31;
          description
            "install update package name";
        }

        container warm {
          description "install update warm";
          leaf packagepath {
            type string;
            description
              "install update warm package path";
          }

          leaf-list packagename {
            type string;
            max-elements 31;
            description
              "install update warm package name";
          }
        }  // container warm

        container warm-force {
          description
            "install update warm force";
          leaf packagepath {
            type string;
            description
              "install update warm force package path";
          }

          leaf-list packagename {
            type string;
            max-elements 31;
            description
              "install update warm force package name";
          }
        }  // container warm-force

        container warm-replace {
          description
            "install update warm replace";
          leaf packagepath {
            type string;
            description
              "install update warm replace package path";
          }

          leaf-list packagename {
            type string;
            max-elements 31;
            description
              "install update warm replace package name";
          }
        }  // container warm-replace

        container warm-replace-force {
          description
            "install update warm replace force";
          leaf packagepath {
            type string;
            description
              "install update warm replace force package path";
          }

          leaf-list packagename {
            type string;
            max-elements 31;
            description
              "install update warm replace force package name";
          }
        }  // container warm-replace-force

        container force {
          description "install update force";
          leaf packagepath {
            type string;
            description
              "install update force package path";
          }

          leaf-list packagename {
            type string;
            max-elements 31;
            description
              "install update force package name";
          }
        }  // container force

        container replace {
          description
            "install update replace";
          leaf packagepath {
            type string;
            description
              "install update replace package path";
          }

          leaf-list packagename {
            type string;
            max-elements 31;
            description
              "install update replace package name";
          }
        }  // container replace

        container replace-force {
          description
            "install update replace force";
          leaf packagepath {
            type string;
            description
              "install update replace force package path";
          }

          leaf-list packagename {
            type string;
            max-elements 31;
            description
              "install update replace force package name";
          }
        }  // container replace-force

        container replace-commit {
          description
            "install update replace commit";
          leaf packagepath {
            type string;
            description
              "install update replace commit package path";
          }

          leaf-list packagename {
            type string;
            max-elements 31;
            description
              "install update replace commit package name";
          }
        }  // container replace-commit

        container replace-commit-force {
          description
            "install update replace commit force";
          leaf packagepath {
            type string;
            description
              "install update replace commit force package path";
          }

          leaf-list packagename {
            type string;
            max-elements 31;
            description
              "install update replace commit force package name";
          }
        }  // container replace-commit-force
      }

      output {
        leaf op-id {
          type string;
          description
            "operation id of the triggered action";
        }

        leaf Error {
          type string;
          description
            "case when op-id is not triggered";
        }
      }
    }  // rpc install-update

    rpc install-replace {
      description
        "Add & Activate packages in given GISO";
      input {
        leaf packagepath {
          type string;
          description
            "install replace package patch";
        }

        container commit {
          description
            "install replace commit";
          leaf packagepath {
            type string;
            description
              "install replace commit package path";
          }
        }  // container commit

        container commit-force {
          description
            "install replace commit force";
          leaf packagepath {
            type string;
            description
              "install replace commit force package path";
          }
        }  // container commit-force
      }

      output {
        leaf op-id {
          type string;
          description
            "operation id of the triggered action";
        }

        leaf Error {
          type string;
          description
            "case when op-id is not triggered";
        }
      }
    }  // rpc install-replace

    rpc install-source {
      description
        "Cli-command install source";
      input {
        leaf packagepath {
          type string;
          description
            "install source package path";
        }

        leaf-list packagename {
          type string;
          max-elements 31;
          description
            "install source package name";
        }

        container reload {
          description
            "install source reload";
          leaf packagepath {
            type string;
            description
              "install source reload package path";
          }

          leaf-list packagename {
            type string;
            max-elements 31;
            description
              "install source reload package name";
          }
        }  // container reload

        container warm {
          leaf packagepath {
            type string;
          }

          leaf-list packagename {
            type string;
            max-elements 31;
          }
        }  // container warm
      }

      output {
        leaf op-id {
          type string;
          description
            "operation id of the triggered action";
        }

        leaf Error {
          type string;
          description
            "case when op-id is not triggered";
        }
      }
    }  // rpc install-source
  }  // module Cisco-IOS-XR-spirit-install-act