module yuma123-netconf {

  // the namespace for NETCONF XML definitions is unchanged
  // from RFC 4741, which this document replaces
  namespace "urn:ietf:params:xml:ns:netconf:base:1.0";

  prefix nc;

  import ietf-inet-types {
    prefix inet;
  }

  import ietf-netconf-acm { prefix nacm; }

  // for the xpath data type
  import ietf-yang-types { prefix "yang"; }

  // for NCX 'metadata' language extension
  import yuma-ncx { prefix "ncx"; }

  // for the uri data type
  import yuma123-netconf-types { prefix "nct"; }

  organization
    "yuma123";

  contact
    "vladimir@transpacket.com";
  description
    "This module imitates ietf-netconf.yang
     with additional YUMA extensions. The solution is a hack
     and the module is only for internal use.";

//  organization
//    "IETF NETCONF (Network Configuration) Working Group";
//
//  contact
//    "WG Web:   <http://tools.ietf.org/wg/netconf/>
//     WG List:  <netconf@ietf.org>
//
//     WG Chair: Bert Wijnen
//               <bertietf@bwijnen.net>
//
//     WG Chair: Mehmet Ersue
//               <mehmet.ersue@nsn.com>
//
//     Editor:   Martin Bjorklund
//               <mbj@tail-f.com>
//
//     Editor:   Juergen Schoenwaelder
//               <j.schoenwaelder@jacobs-university.de>
//
//     Editor:   Andy Bierman
//               <andy.bierman@brocade.com>";
//  description
//    "NETCONF Protocol Data Types and Protocol Operations.
//
//     Copyright (c) 2011 IETF Trust and the persons identified as
//     the document authors.  All rights reserved.
//
//     Redistribution and use in source and binary forms, with or
//     without modification, is permitted pursuant to, and subject
//     to the license terms contained in, the Simplified BSD License
//     set forth in Section 4.c of the IETF Trust's Legal Provisions
//     Relating to IETF Documents
//     (http://trustee.ietf.org/license-info).
//
//     This version of this YANG module is part of RFC 6241; see
//     the RFC itself for full legal notices.";
//
//  revision 2011-06-01 {
//    description
//      "Initial revision;
//       2013-09-29: Updated to include NACM attributes, 
//       as specified in RFC 6536: sec 3.2.5 and 3.2.8";
//    reference
//      "RFC 6241: Network Configuration Protocol";
//  }

  revision 2017-06-22 {
    description
      "Synced with the latest RFC 6241 module.";
  }
  revision 2017-03-26 {
    description
      "Changed namespace in order to edit the original
       netconfcentral model. Splitted yuma-netconf
       into yuma123-netconf and yuma123-netconf-types";
  }


  extension get-filter-element-attributes {
    description
      "If this extension is present within an 'anyxml'
       statement named 'filter', which must be conceptually
       defined within the RPC input section for the <get>
       and <get-config> protocol operations, then the
       following unqualified XML attribute is supported
       within the <filter> element, within a <get> or
       <get-config> protocol operation:

         type : optional attribute with allowed
                value strings 'subtree' and 'xpath'.
                If missing, the default value is 'subtree'.

       If the 'xpath' feature is supported, then the
       following unqualified XML attribute is
       also supported:

         select: optional attribute containing a
                 string representing an XPath expression.
                 The 'type' attribute must be equal to 'xpath'
                 if this attribute is present.";
  }

  // NETCONF capabilities defined as features
  feature writable-running {
    description
      "NETCONF :writable-running capability;
       If the server advertises the :writable-running
       capability for a session, then this feature must
       also be enabled for that session.  Otherwise,
       this feature must not be enabled.";
    reference "RFC 6241, Section 8.2";
  }

  feature candidate {
    description
      "NETCONF :candidate capability;
       If the server advertises the :candidate
       capability for a session, then this feature must
       also be enabled for that session.  Otherwise,
       this feature must not be enabled.";
    reference "RFC 6241, Section 8.3";
  }

  feature confirmed-commit {
    if-feature candidate;
    description
      "NETCONF :confirmed-commit:1.1 capability;
       If the server advertises the :confirmed-commit:1.1
       capability for a session, then this feature must
       also be enabled for that session.  Otherwise,
       this feature must not be enabled.";

    reference "RFC 6241, Section 8.4";
  }

  feature rollback-on-error {
    description
      "NETCONF :rollback-on-error capability;
       If the server advertises the :rollback-on-error
       capability for a session, then this feature must
       also be enabled for that session.  Otherwise,
       this feature must not be enabled.";
    reference "RFC 6241, Section 8.5";
  }

  feature validate {
    description
      "NETCONF :validate:1.1 capability;
       If the server advertises the :validate:1.1
       capability for a session, then this feature must
       also be enabled for that session.  Otherwise,
       this feature must not be enabled.";
    reference "RFC 6241, Section 8.6";
  }

  feature startup {
    description
      "NETCONF :startup capability;
       If the server advertises the :startup
       capability for a session, then this feature must
       also be enabled for that session.  Otherwise,
       this feature must not be enabled.";
    reference "RFC 6241, Section 8.7";
  }

  feature url {
    description
      "NETCONF :url capability;
       If the server advertises the :url
       capability for a session, then this feature must
       also be enabled for that session.  Otherwise,
       this feature must not be enabled.";
    reference "RFC 6241, Section 8.8";
  }

  feature xpath {
    description
      "NETCONF :xpath capability;
       If the server advertises the :xpath
       capability for a session, then this feature must
       also be enabled for that session.  Otherwise,
       this feature must not be enabled.";
    reference "RFC 6241, Section 8.9";
  }

  container server-hello {
    description "Generic Server Hello Message Parameters.";

    uses nct:NcCapabilities;

    leaf session-id {
       type nc:session-id-type;
       config false;
    }

    ncx:hidden;
    ncx:abstract;
  }

  container client-hello {

    description "Generic Client Hello Message Parameters.";

    uses nct:NcCapabilities;

    ncx:hidden;
    ncx:abstract;
  }


  // NETCONF Operations PDU Data Types

  grouping ErrorInfoContent {
    description 
      "NETCONF standard 'error-info' Element Content;";

    leaf-list bad-attribute {
      description
        "Name of the missing or invalid XSD attribute.
         Used with missing-attribute, bad-attribute, and
         unknown-attribute error-tag values.";
      type   string;           // xs:QName
      config false;
    }

    leaf-list bad-element {
      description
        "Name of the element that contains (or should contain)
         an invalid XSD attribute when used with missing-attribute,
         bad-attribute, unknown-attribute, error-tag values.
         Name of an invalid or missing element when used with
         then missing-element, bad-element, unknown-element,
         and unknown-namespace error-tag values.";
      type   string;             // xs:QName
      config false;
    }

    leaf-list ok-element {
      description 
        "Identifies an element in the data model
         for which the requested operation has been completed
         for that node and all its child nodes.  This element
         can appear zero or more times in the 'error-info'
         container.  Used with the partial-operation error-tag
         value.";
      type   string;                    // xs:QName
      config false;
    }

    leaf-list err-element {
      description
        "Identifies an element in the data model
         for which the requested operation has failed for that
         node and all its child nodes.  This element
         can appear zero or more times in the 'error-info'
         container.   Used with the partial-operation error-tag
         value.";
       type   string;                   // xs:QName
       config false;
     }

     leaf-list noop-element {
       description
         "Identifies an element in the data model
          for which the requested operation was not attempted for
          that node and all its child nodes.  This element
          can appear zero or more times in the <error-info>
          container.   Used with the partial-operation error-tag
          value.";
       type   string;                  // xs:QName
       config false;
     }

     leaf session-id {
      description
        "Session ID of session holding the
         requested lock, or zero to indicate a non-NETCONF
         entity holds the lock.";
       type session-id-or-zero-type;
       config false;
     }
  }

  // NETCONF Simple Types

  typedef session-id-type {
    type uint32 {
      range "1..max";
    }
    description
      "NETCONF Session Id";
  }

  typedef session-id-or-zero-type {
    type uint32;
    description
      "NETCONF Session Id or Zero to indicate none";
  }
  typedef error-tag-type {
    type enumeration {
       enum in-use {
         description
           "The request requires a resource that
            already is in use.";
       }
       enum invalid-value {
         description
           "The request specifies an unacceptable value for one
            or more parameters.";
       }
       enum too-big {
         description
           "The request or response (that would be generated) is
            too large for the implementation to handle.";
       }
       enum missing-attribute {
         description
           "An expected attribute is missing.";
       }
       enum bad-attribute {
         description
           "An attribute value is not correct; e.g., wrong type,
            out of range, pattern mismatch.";
       }
       enum unknown-attribute {
         description
           "An unexpected attribute is present.";
       }
       enum missing-element {
         description
           "An expected element is missing.";
       }
       enum bad-element {
         description
           "An element value is not correct; e.g., wrong type,
            out of range, pattern mismatch.";
       }
       enum unknown-element {
         description
           "An unexpected element is present.";
       }
       enum unknown-namespace {
         description
           "An unexpected namespace is present.";
       }
       enum access-denied {
         description
           "Access to the requested protocol operation or
            data model is denied because authorization failed.";
       }
       enum lock-denied {
         description
           "Access to the requested lock is denied because the
            lock is currently held by another entity.";
       }
       enum resource-denied {
         description
           "Request could not be completed because of
            insufficient resources.";
       }
       enum rollback-failed {
         description
           "Request to roll back some configuration change (via
            rollback-on-error or <discard-changes> operations)
            was not completed for some reason.";

       }
       enum data-exists {
         description
           "Request could not be completed because the relevant
            data model content already exists.  For example,
            a 'create' operation was attempted on data that
            already exists.";
       }
       enum data-missing {
         description
           "Request could not be completed because the relevant
            data model content does not exist.  For example,
            a 'delete' operation was attempted on
            data that does not exist.";
       }
       enum operation-not-supported {
         description
           "Request could not be completed because the requested
            operation is not supported by this implementation.";
       }
       enum operation-failed {
         description
           "Request could not be completed because the requested
            operation failed for some reason not covered by
            any other error condition.";
       }
       enum partial-operation {
         description
           "This error-tag is obsolete, and SHOULD NOT be sent
            by servers conforming to this document.";
       }
       enum malformed-message {
         description
           "A message could not be handled because it failed to
            be parsed correctly.  For example, the message is not
            well-formed XML or it uses an invalid character set.";
       }
     }
     description "NETCONF Error Tag";
     reference "RFC 6241, Appendix A";
  }

  typedef error-severity-type {
    type enumeration {
      enum error {
        description "Error severity";
      }
      enum warning {
        description "Warning severity";
      }
    }
    description "NETCONF Error Severity";
    reference "RFC 6241, Section 4.3";
  }

  typedef edit-operation-type {
    type enumeration {
      enum merge {
        description
          "The configuration data identified by the
           element containing this attribute is merged
           with the configuration at the corresponding
           level in the configuration datastore identified
           by the target parameter.";
      }
      enum replace {
        description
          "The configuration data identified by the element
           containing this attribute replaces any related
           configuration in the configuration datastore
           identified by the target parameter.  If no such
           configuration data exists in the configuration
           datastore, it is created.  Unlike a
           <copy-config> operation, which replaces the
           entire target configuration, only the configuration
           actually present in the config parameter is affected.";
      }
      enum create {
        description
          "The configuration data identified by the element
           containing this attribute is added to the
           configuration if and only if the configuration
           data does not already exist in the configuration
           datastore.  If the configuration data exists, an
           <rpc-error> element is returned with an
           <error-tag> value of 'data-exists'.";
      }
      enum delete {
        description
          "The configuration data identified by the element
           containing this attribute is deleted from the
           configuration if and only if the configuration
           data currently exists in the configuration
           datastore.  If the configuration data does not
           exist, an <rpc-error> element is returned with
           an <error-tag> value of 'data-missing'.";
      }
      enum remove {
        description
          "The configuration data identified by the element
           containing this attribute is deleted from the
           configuration if the configuration
           data currently exists in the configuration
           datastore.  If the configuration data does not
           exist, the 'remove' operation is silently ignored
           by the server.";
      }
    }
    default "merge";
    description "NETCONF 'operation' attribute values";
    reference "RFC 6241, Section 7.2";
  }

  grouping RpcErrorType {
     description "NETCONF 'rpc-error' Element Content";

     leaf error-type {
       description 
         "Defines the conceptual layer that the error occurred.";
       type nct:ErrorType;
       mandatory true;
     }

     leaf error-tag {
       description
         "Contains a string identifying the error condition.";
       type nct:error-tag-type;
       mandatory true;
     }

     leaf error-severity {
       description
         "Contains a string identifying the error severity, as
          determined by the device.";
       type nct:error-severity-type;
       mandatory true;
     }

     leaf error-app-tag {
       description
         "Contains a string identifying the data-model-specific
          or implementation-specific error condition, if one exists.
          This element will not be present if no appropriate 
          application error tag can be associated with a particular
          error condition.";
       type string;
     }

    leaf error-path {
      description
        "Contains the absolute XPath [2] expression identifying
         the element path to the node that is associated with the error
         being reported in a particular rpc-error element.  This element
         will not be present if no appropriate payload element can be
         associated with a particular error condition, or if the
         'bad-element' QString returned in the 'error-info' container is
         sufficient to identify the node associated with the error.  When
         the XPath expression is interpreted, the set of namespace
         declarations are those in scope on the rpc-error element,
         including the default namespace.";
      type yang:xpath1.0;
    }

    leaf error-message {
      description
        "Contains a string suitable for human display that
         describes the error condition.  This element will not be present
         if no appropriate message is provided for a particular error
         condition.  This element SHOULD include an xml:lang attribute.";
      type nct:LangString;
    }

    anyxml error-info {
      description
        "Contains protocol- or data-model-specific error content.
         This element will not be present if no such error content is
         provided for a particular error condition.  The list in 
         RFC 4741, Appendix A, defines any mandatory error-info content 
         for each error.  After any protocol-mandated content, a 
         data model definition may mandate that certain application-layer
         error information be included in the error-info container. 
         An implementation may include additional elements to 
         provide extended and/or implementation-specific debugging 
         information.";
    }
  }

  grouping RpcDataReplyType {
    description "NETCONF 'rpc-reply' Error and/or Data Content";

    list rpc-error {
      config false;
      uses RpcErrorType;
    }
    // anyxml data {
    //   config false;
    // }
    // any XML is allowed here, not just 1 el. named data
    // The contents of the 'rpc output' section appears here
  }

  grouping RpcOkReplyType {
    description "NETCONF 'rpc-reply' OK Content.";

    choice ok-or-error {
      leaf ok {
        description
          "Sent in 'rpc-reply' messages if no errors or
           warnings occurred during the processing of an 'rpc' request.";
        type empty;
        config false;
      }

      list rpc-error {
        config false;
        uses RpcErrorType;
      }
    }
  }

  grouping RpcReplyType {
    description "Generic NETCONF 'rpc-reply' content. ";

    choice ok-or-data-error {
      mandatory true;
      config false;

      leaf ok {
        description
          "Sent in 'rpc-reply' messages if no errors or
           warnings occurred during the processing of an 'rpc' request.";
        type empty;
      }

      case data-error {
         uses RpcDataReplyType;
      }
    }
  }


  // NETCONF operation attribute
  leaf operation {
    description 
      "Internal object for the nc:operation attribute.";
    type nc:edit-operation-type;
    ncx:abstract;
    ncx:hidden;
  }

  // NETCONF Generic RPC Messages

  container rpc {
    description "Remote Procedure Call request message";
   
    reference "RFC 4741, section 4.1";

    // do not treat missing message-id as an error
    ncx:metadata  "nct:MessageId message-id";
    ncx:abstract;
  }

  container rpc-reply {
    description "Remote Procedure Call response message";

    reference "RFC 4741, section 4.2";

    uses RpcReplyType;

    // do not treat missing message-id as an error
    ncx:metadata  "nct:MessageId message-id";
    ncx:abstract;
  }

  // NETCONF Standard Protocol Operations

  rpc get-config {
    description
      "Retrieve all or part of a specified configuration.";

    reference "RFC 6241, Section 7.1";

    input {
      container source {
        description
          "Particular configuration to retrieve.";

        choice config-source {
          mandatory true;
          description
            "The configuration to retrieve.";
          leaf candidate {
            if-feature candidate;
            type empty;
            description
              "The candidate configuration is the config source.";
          }
          leaf running {
            type empty;
            description
              "The running configuration is the config source.";
          }
          leaf startup {
            if-feature startup;
            type empty;
            description
              "The startup configuration is the config source.
               This is optional-to-implement on the server because
               not all servers will support filtering for this
               datastore.";
          }
        }
      }

      anyxml filter {
        description
          "Subtree or XPath filter to use.";
        nc:get-filter-element-attributes;
        ncx:metadata "nct:FilterType type";
        ncx:metadata "nct:SelectString select";

      }
    }

    output {
      container data {
        presence 
          "An empty data container indicates that the
           request did not produce any results.";

        description
          "Copy of the source datastore subset that matched
           the filter criteria (if any).  An empty data container
           indicates that the request did not produce any results.";

        ncx:root;
      }
    }
  }

  rpc edit-config {
    description
      "The <edit-config> operation loads all or part of a specified
       configuration to the specified target configuration.";

    reference "RFC 6241, Section 7.2";

    input {
      container target {
        description
          "Particular configuration to edit.";

        choice config-target {
          mandatory true;
          description
            "The configuration target.";

          leaf candidate {
            if-feature candidate;
            type empty;
            description
              "The candidate configuration is the config target.";
          }
          leaf running {
            if-feature writable-running;
            type empty;
            description
              "The running configuration is the config source.";
          }
        }
      }

      leaf default-operation {
        type enumeration {
          enum merge {
            description
              "The default operation is merge.";
          }
          enum replace {
            description
              "The default operation is replace.";
          }
          enum none {
            description
              "There is no default operation.";
          }
        }
        default "merge";
        description
          "The default operation to use.";
      }

      leaf test-option {
        if-feature validate;
        type enumeration {
          enum test-then-set {
            description
              "The server will test and then set if no errors.";
          }
          enum set {
            description
              "The server will set without a test first.";
          }

          enum test-only {
            description
              "The server will only test and not set, even
               if there are no errors.";
          }
        }
        default "test-then-set";
        description
          "The test option to use.";
      }

      leaf error-option {
        type enumeration {
          enum stop-on-error {
            description
              "The server will stop on errors.";
          }
          enum continue-on-error {
            description
              "The server may continue on errors.";
          }
          enum rollback-on-error {
            description
              "The server will roll back on errors.
               This value can only be used if the 'rollback-on-error'
               feature is supported.";
          }
        }
        default "stop-on-error";
        description
          "The error option to use.";
      }

      choice edit-content {
        mandatory true;
        description
          "The content for the edit operation.";

        container config {
          description
            "Inline Config content.";
          ncx:root;
        }
        leaf url {
          if-feature url;
          type inet:uri;
          description
            "URL-based config content.";
        }
      }
    }
  }

  rpc copy-config {
    description
      "Create or replace an entire configuration datastore with the
       contents of another complete configuration datastore.";

    reference "RFC 6241, Section 7.3";

    input {
      container target {
        description
          "Particular configuration to copy to.";

        choice config-target {
          mandatory true;
          description
            "The configuration target of the copy operation.";

          leaf candidate {
            if-feature candidate;
            type empty;
            description
              "The candidate configuration is the config target.";
          }
          leaf running {
            if-feature writable-running;
            type empty;
            description
              "The running configuration is the config target.
               This is optional-to-implement on the server.";
          }
          leaf startup {
            if-feature startup;
            type empty;
            description
              "The startup configuration is the config target.";
          }
          leaf url {
            if-feature url;
            type inet:uri;
            description
              "The URL-based configuration is the config target.";
          }
        }
      }

      container source {
        description
          "Particular configuration to copy from.";

        choice config-source {
          mandatory true;
          description
            "The configuration source for the copy operation.";

          leaf candidate {
            if-feature candidate;
            type empty;
            description
              "The candidate configuration is the config source.";
          }
          leaf running {
            type empty;
            description
              "The running configuration is the config source.";
          }
          leaf startup {
            if-feature startup;
            type empty;
            description
              "The startup configuration is the config source.";
          }
          leaf url {
            if-feature url;
            type inet:uri;
            description
              "The URL-based configuration is the config source.";
          }
          container config {
            description
              "Inline Config content: <config> element.  Represents
               an entire configuration datastore, not
               a subset of the running datastore.";
            ncx:root;
          }
        }
      }
    }
  }

  rpc delete-config {
    nacm:default-deny-all;
    description
      "Delete a configuration datastore.";

    reference "RFC 6241, Section 7.4";

    input {
      container target {
        description
          "Particular configuration to delete.";

        choice config-target {
          mandatory true;
          description
            "The configuration target to delete.";

          leaf startup {
            if-feature startup;
            type empty;
            description
              "The startup configuration is the config target.";
          }
          leaf url {
            if-feature url;
            type inet:uri;
            description
              "The URL-based configuration is the config target.";
          }
        }
      }
    }
  }

  rpc lock {
    description
      "The lock operation allows the client to lock the configuration
       system of a device.";

    reference "RFC 6241, Section 7.5";

    input {
      container target {
        description
          "Particular configuration to lock.";

        choice config-target {
          mandatory true;
          description
            "The configuration target to lock.";

          leaf candidate {
            if-feature candidate;
            type empty;
            description
              "The candidate configuration is the config target.";
          }
          leaf running {
            type empty;
            description
              "The running configuration is the config target.";
          }
          leaf startup {
            if-feature startup;
            type empty;
            description
              "The startup configuration is the config target.";
          }
        }
      }
    }
  }

  rpc unlock {
    description
      "The unlock operation is used to release a configuration lock,
       previously obtained with the 'lock' operation.";

    reference "RFC 6241, Section 7.6";

    input {
      container target {
        description
          "Particular configuration to unlock.";

        choice config-target {
          mandatory true;
          description
            "The configuration target to unlock.";

          leaf candidate {
            if-feature candidate;
            type empty;
            description
              "The candidate configuration is the config target.";
          }
          leaf running {
            type empty;
            description
              "The running configuration is the config target.";
          }
          leaf startup {
            if-feature startup;
            type empty;
            description
              "The startup configuration is the config target.";
          }
        }
      }
    }
  }

  rpc get {
    description
      "Retrieve running configuration and device state information.";

    reference "RFC 6241, Section 7.7";

    input {
      anyxml filter {
        description
          "This parameter specifies the portion of the system
           configuration and state data to retrieve.";
        nc:get-filter-element-attributes;
        ncx:metadata "nct:FilterType type";
        ncx:metadata "string select";

      }
    }

    output {
      container data {
        description
          "Copy of the running datastore subset and/or state
           data that matched the filter criteria (if any).
           An empty data container indicates that the request did not
           produce any results.";
        ncx:root;
      }
    }
  }

  rpc close-session {
    description
      "Request graceful termination of a NETCONF session.";

    reference "RFC 6241, Section 7.8";
  }

  rpc kill-session {
    nacm:default-deny-all;
    description
      "Force the termination of a NETCONF session.";

    reference "RFC 6241, Section 7.9";

    input {
      leaf session-id {
        type session-id-type;
        mandatory true;
        description
          "Particular session to kill.";
      }
    }
  }

  rpc commit {
    if-feature candidate;

    description
      "Commit the candidate configuration as the device's new
       current configuration.";

    reference "RFC 6241, Section 8.3.4.1";

    input {
      leaf confirmed {
        if-feature confirmed-commit;
        type empty;
        description
          "Requests a confirmed commit.";
        reference "RFC 6241, Section 8.3.4.1";
      }

      leaf confirm-timeout {
        if-feature confirmed-commit;
        type uint32 {
          range "1..max";
        }
        units "seconds";
        default "600";   // 10 minutes
        description
          "The timeout interval for a confirmed commit.";
        reference "RFC 6241, Section 8.3.4.1";
      }

      leaf persist {
        if-feature confirmed-commit;
        type string;
        description
          "This parameter is used to make a confirmed commit
           persistent.  A persistent confirmed commit is not aborted
           if the NETCONF session terminates.  The only way to abort
           a persistent confirmed commit is to let the timer expire,
           or to use the <cancel-commit> operation.

           The value of this parameter is a token that must be given
           in the 'persist-id' parameter of <commit> or
           <cancel-commit> operations in order to confirm or cancel
           the persistent confirmed commit.

           The token should be a random string.";
        reference "RFC 6241, Section 8.3.4.1";
      }

      leaf persist-id {
        if-feature confirmed-commit;
        type string;
        description
          "This parameter is given in order to commit a persistent
           confirmed commit.  The value must be equal to the value
           given in the 'persist' parameter to the <commit> operation.
           If it does not match, the operation fails with an
          'invalid-value' error.";
        reference "RFC 6241, Section 8.3.4.1";
      }

    }
  }

  rpc discard-changes {
    if-feature candidate;

    description
      "Revert the candidate configuration to the current
       running configuration.";
    reference "RFC 6241, Section 8.3.4.2";
  }

  rpc cancel-commit {
    if-feature confirmed-commit;
    description
      "This operation is used to cancel an ongoing confirmed commit.
       If the confirmed commit is persistent, the parameter
       'persist-id' must be given, and it must match the value of the
       'persist' parameter.";
    reference "RFC 6241, Section 8.4.4.1";

    input {
      leaf persist-id {
        type string;
        description
          "This parameter is given in order to cancel a persistent
           confirmed commit.  The value must be equal to the value
           given in the 'persist' parameter to the <commit> operation.
           If it does not match, the operation fails with an
          'invalid-value' error.";
      }
    }
  }

  rpc validate {
    if-feature validate;

    description
      "Validates the contents of the specified configuration.";

    reference "RFC 6241, Section 8.6.4.1";

    input {
      container source {
        description
          "Particular configuration to validate.";

        choice config-source {
          mandatory true;
          description
            "The configuration source to validate.";

          leaf candidate {
            if-feature candidate;
            type empty;
            description
              "The candidate configuration is the config source.";
          }
          leaf running {
            type empty;
            description
              "The running configuration is the config source.";
          }
          leaf startup {
            if-feature startup;
            type empty;
            description
              "The startup configuration is the config source.";
          }
          leaf url {
            if-feature url;
            type inet:uri;
            description
              "The URL-based configuration is the config source.";
          }
          container config {
            description
              "Inline Config content: <config> element.  Represents
               an entire configuration datastore, not
               a subset of the running datastore.";
            ncx:root;
          }
        }
      }
    }
  }
  rpc load-config {
    ncx:hidden;
    ncx:abstract;

    description 
      "NCX internal load-config operation.
       The config database can be loaded dynamically
       only if the startup config phase was skipped
       via the 'no-startup' option.

       An operation-failed error will be returned and
       any startup config file was loaded (even partially)
       successfully.";

    input {
      container config {
        ncx:root;
        description "XML Config contents.";
      }
    }
  }

  container config {
    description 
      "Used as the container for NETCONF object definitions.";
    ncx:root;
    ncx:abstract;
  }

}
