<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns="http://netconfcentral.org/ns/yangcli"
  targetNamespace="http://netconfcentral.org/ns/yangcli"
  elementFormDefault="qualified" attributeFormDefault="unqualified"
  xml:lang="en" version="2011-10-10"
  xmlns:ncx="http://netconfcentral.org/ns/yuma-ncx"
  xmlns:nc="urn:ietf:params:xml:ns:netconf:base:1.0"
  xmlns:yang="urn:ietf:params:xml:ns:yang:ietf-yang-types"
  xmlns:appcmn="http://netconfcentral.org/ns/yuma-app-common"
  xmlns:yt="http://netconfcentral.org/ns/yuma-types">
  <xs:annotation>
    <xs:documentation>Converted from YANG file 'yangcli.yang' by yangdump version 2.2.1737
      
      Module: yangcli
      Organization: Netconf Central
      Version: 2011-10-10
      Contact: Andy Bierman &lt;support@netconfcentral.org&gt;.</xs:documentation>
    <xs:documentation>
      Command Line Interface for the NETCONF protocol: Client side
      
      Usage:
         yangcli [parameters]
         yangcli --help
         yangcli --version
      
      Normal Mode:
         An interactive CLI shell with command line history.
      
      Autostart-mode:
         If the 'server' parameter is present, then yangcli will
         attempt to connect to that server upon startup.  If the
         'user' and 'password' parameters are also present, then
         the user will not be prompted before the connection
         is attempted.  This parameter will be processed first,
         if script-mode or batch-mode is used.
      
      Script-mode:
         If the 'run-script' or 'run-command' parameter is present,
         then the specified script or command will be run
         automatically upon startup.
      
      Batch-mode:
         If the 'batch-mode' parameter is present, then either the
         'run-script' or 'run-command' parameter will be invoked, if
         present, and then the program will exit.  Any interactive
         input breaks in the script or command will be skipped.
       </xs:documentation>
    <xs:appinfo>
      <ncx:source>/usr/share/yuma/modules/netconfcentral/yangcli.yang</ncx:source>
      <ncx:organization>Netconf Central</ncx:organization>
      <ncx:contact>Andy Bierman &lt;support@netconfcentral.org&gt;.</ncx:contact>
    </xs:appinfo>
    <xs:appinfo>
      <ncx:revision>
        <ncx:version>2011-10-10</ncx:version>
        <ncx:description>Add CLI parameters:
            --aliases-file
            --autoaliases
            --autouservars
            --uservars-file
            --home
          Add yangcli local commands:
            alias
            aliases
            unset
            uservars
          </ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2011-09-05</ncx:version>
        <ncx:description>Add 'json' to --display-mode enumerations.</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2011-08-06</ncx:version>
        <ncx:description>Add --transport to ConnectParms grouping.</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2011-07-19</ncx:version>
        <ncx:description>Add PublicKeyParms grouping.
          Added MatchParms (--match-names and --alt-names).
          Added --force-target parameter.
          Added show session command.
          Added --urltarget=&lt;url&gt; parameter to FillParms grouping
          to allow URL encoded requests to be converted to XPath
          before use.
          Added --use-xmlheader=&lt;boolean&gt; parameter to control
          how XML file variables are generated when written.</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2011-06-05</ncx:version>
        <ncx:description>Added start-timer and stop-timer local RPC functions.
          Added --echo-replies parameter and system variable.
          Added --time-rpcs parameter and system variable
          Added remove command for base:1.1 support</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2011-04-22</ncx:version>
        <ncx:description>Added --protocols parm via uses ProtocolsParm.
          Also allow setting --protocols in &lt;connect&gt; RPC.</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2011-03-19</ncx:version>
        <ncx:description>Added 'xml-nons' display mode to display-mode parameter.
          Added 'cli' and 'system' to show command; subset of
          show vars.
          Changed history show default from -1 to 25.</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2010-04-16</ncx:version>
        <ncx:description>Added eval command for XPath expression support</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2010-01-14</ncx:version>
        <ncx:description>Initial published version for 0.9.9 release</ncx:description>
      </ncx:revision>
    </xs:appinfo>
  </xs:annotation>
  <xs:simpleType name="LogCount">
    <xs:annotation>
      <xs:documentation>Number of log entries. -1 means all entries</xs:documentation>
    </xs:annotation>
    <xs:union>
      <xs:simpleType>
        <xs:restriction base="xs:int">
          <xs:minInclusive value="-1"/>
          <xs:maxInclusive value="-1"/>
        </xs:restriction>
      </xs:simpleType>
      <xs:simpleType>
        <xs:restriction base="xs:int">
          <xs:minInclusive value="1"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
  <xs:simpleType name="LogIndex">
    <xs:annotation>
      <xs:documentation>Index into a log buffer.</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:unsignedInt"/>
  </xs:simpleType>
  <xs:simpleType name="TimerId">
    <xs:annotation>
      <xs:documentation>Identifier for a local timer to use with
        the start-timer and stop-timer commands.</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:unsignedByte">
      <xs:maxInclusive value="15"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NameMatchMode">
    <xs:annotation>
      <xs:documentation>Defines the search mode that should be used
        when resolving YANG node names in leafs and
        leaf-lists using the UrlPath data type.</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:enumeration value="exact">
        <xs:annotation>
          <xs:documentation>The name must exactly match the node name
            for all characters in both name strings.</xs:documentation>
          <xs:appinfo>
            <ncx:value>0</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="exact-nocase">
        <xs:annotation>
          <xs:documentation>The name must match the node name
            for all characters in both name strings.
            Strings are not case-sensitive.</xs:documentation>
          <xs:appinfo>
            <ncx:value>1</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="one">
        <xs:annotation>
          <xs:documentation>The name must exactly match the first N
            characters of just one node name, which
            must be the only partial name match found.</xs:documentation>
          <xs:appinfo>
            <ncx:value>2</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="one-nocase">
        <xs:annotation>
          <xs:documentation>The name must exactly match the first N
            characters of just one node name, which
            must be the only partial name match found.
            Strings are not case-sensitive.</xs:documentation>
          <xs:appinfo>
            <ncx:value>3</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="first">
        <xs:annotation>
          <xs:documentation>The name must exactly match the first N
            characters of any node name. The first one
            found will be used.</xs:documentation>
          <xs:appinfo>
            <ncx:value>4</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="first-nocase">
        <xs:annotation>
          <xs:documentation>The name must exactly match the first N
            characters of any node name. The first one
            found will be used. Strings are not
            case-sensitive.</xs:documentation>
          <xs:appinfo>
            <ncx:value>5</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="AltNameMode">
    <xs:annotation>
      <xs:documentation>Defines the alternate name search mode that
        should be used when resolving YANG node names
        in leafs or leaflists using the UrlPath data type.
        
        If 'true' then nodes with an 'alt-name' defined
        will be considered a match if the YANG name or the
        alternative name matches the search string.
        
        If 'false' then only the YANG node name will
        be used in node name searches.</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:boolean"/>
  </xs:simpleType>
  <xs:simpleType name="UrlPath">
    <xs:annotation>
      <xs:documentation>Special URL encoded path expression.
        
        Normal Encoding Rules:
        
          - Normal content is encoded as an absolute path.
          - Keys are encoded as a path step within the URL,
            instead of a predicate expression like XPath.
          - The first character must be a forward slash '/'.
          - Each identifier or key encoded in the URL string
            is separated by a single forward slash '/' character.
          - Escaped character sequences are allowed, such
            as '%20' for the space ' ' character.
          - If any descendant nodes of a list are included,
            then all key leafs for that list must be encoded
            in the URL (or escaped with the dash '-' character
            to skip that key).
          - Only key leafs can be encoded within the URL string,
            similar to a YANG instance-identifier or
            schema-instance-identifier string.  Other leafs
            are not allowed.
        
          Example URL and XPath strings:
        
              XPath:  /foo/bar[id='fred'][id2='barney]/baz
        
            UrlPath:  /foo/bar/fred/barney/baz
        
          Example showing the 'id2' key leaf escaped:
        
              XPath:  /foo/bar[id='fred']/baz
        
            UrlPath:  /foo/bar/fred/-/baz
        
        Special Encoding Rules
        
          Since these escaped characters are usually decoded
          by the time an HTTP gateway program will get them,
          the forward slash '/' character needs to be treated
          differently.  To use this character within key leaf
          content, it must be escaped with another forward
          slash character.
        
          Example showing escaped forward slash in content:
        
            XPath: /interfaces/interface[name='1/0/22']/mtu
        
          URLPath: /interfaces/interface/1//0//22/mtu
        
        Name Matching
        
          A parameter using the 'NameMatchMode' data type
          can be used to control how name node searches
          are done for nodes using this data type.
        
        Alternate Naming
        
          A parameter using the 'AltNameMode' data type
          can be used to control whether alternative
          node names can be used when name searches
          are done for nodes using this data type.
        
        Exceptions:
        
          XML namespaces are not ignored, but if multiple
          sibling nodes have the same local-name, then
          the first node found will be used.
        
        </xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:minLength value="1"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="YangcliVariableType">
    <xs:annotation>
      <xs:documentation>yangcli user and system variable types</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:enumeration value="session">
        <xs:annotation>
          <xs:documentation>Session variable (for future use)</xs:documentation>
          <xs:appinfo>
            <ncx:value>0</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="local">
        <xs:annotation>
          <xs:documentation>Local user variable</xs:documentation>
          <xs:appinfo>
            <ncx:value>1</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="config">
        <xs:annotation>
          <xs:documentation>User configuration variable</xs:documentation>
          <xs:appinfo>
            <ncx:value>2</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="global">
        <xs:annotation>
          <xs:documentation>Global user variable</xs:documentation>
          <xs:appinfo>
            <ncx:value>3</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="system">
        <xs:annotation>
          <xs:documentation>System variable</xs:documentation>
          <xs:appinfo>
            <ncx:value>4</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="queue">
        <xs:annotation>
          <xs:documentation>System internal Queue variable</xs:documentation>
          <xs:appinfo>
            <ncx:value>5</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
  <xs:group name="MatchParms">
    <xs:sequence>
      <xs:element name="match-names" type="NameMatchMode" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name="alt-names" type="AltNameMode" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
        </xs:annotation>
      </xs:element>
    </xs:sequence>
  </xs:group>
  <xs:group name="FillParms">
    <xs:sequence>
      <xs:choice>
        <xs:annotation>
          <xs:appinfo>
            <ncx:choice-name>target-parm</ncx:choice-name>
          </xs:appinfo>
        </xs:annotation>
        <xs:sequence>
          <xs:annotation>
            <xs:appinfo>
              <ncx:case-name>target</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:element name="target">
            <xs:annotation>
              <xs:documentation>XPath target object to fill.  If prefixes are missing
                then the first match in any namespace will be used.
                Any prefix used must be the default prefix
                assigned to the desired YANG module. Prefix usage is
                optional.</xs:documentation>
              <xs:appinfo>
                <ncx:mandatory>true</ncx:mandatory>
                <ncx:schema-instance/>
              </xs:appinfo>
            </xs:annotation>
            <xs:simpleType>
              <xs:restriction base="xs:string">
                <xs:minLength value="1"/>
              </xs:restriction>
            </xs:simpleType>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
        <xs:sequence>
          <xs:annotation>
            <xs:appinfo>
              <ncx:case-name>urltarget</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:element name="urltarget" type="UrlPath">
            <xs:annotation>
              <xs:documentation>URL encoded target object to fill.
                Encoding Rules: TBD.</xs:documentation>
              <xs:appinfo>
                <ncx:mandatory>true</ncx:mandatory>
              </xs:appinfo>
            </xs:annotation>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
        <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"
          processContents="lax"/>
      </xs:choice>
      <xs:element name="optional" minOccurs="0">
        <xs:annotation>
          <xs:documentation>If present, then prompt for leafs that are optional.
            If not, skip these objects.</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name="value" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Contains a string representing the content
            to use for the filled variable.
            
            If a string is entered, then the target value being
            filled must be a leaf or leaf-list.
            
            If a variable is referenced, then it will
            be used as the content, if the target value being
            filled is a leaf or a leaf-list.
            
            If the target value is a complex object,
            then the referenced variable must also be
            a complex object of the same type. E.g.,
            
            The global variable 'foo' would be specified as:
            
                value=$$foo
            
            The local variable 'bar' would be specified as:
            
                value=$bar
            
            An error will be reported if the global or local
            variable does not reference the same object type
            as the target parameter.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
          <xs:complexContent>
            <xs:extension base="xs:anyType"/>
          </xs:complexContent>
        </xs:complexType>
      </xs:element>
      <xs:element name="match-names" type="NameMatchMode" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
          <xs:appinfo>
            <ncx:config>true</ncx:config>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="alt-names" type="AltNameMode" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
          <xs:appinfo>
            <ncx:config>true</ncx:config>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
    </xs:sequence>
  </xs:group>
  <xs:group name="CommonPduParms">
    <xs:annotation>
      <xs:documentation>Common parms for some local commands that
        generate NETCONF PDUs</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:choice>
        <xs:annotation>
          <xs:appinfo>
            <ncx:choice-name>from</ncx:choice-name>
            <ncx:mandatory>true</ncx:mandatory>
          </xs:appinfo>
        </xs:annotation>
        <xs:sequence>
          <xs:annotation>
            <xs:appinfo>
              <ncx:case-name>varref</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:element name="varref" type="xs:string" minOccurs="0">
            <xs:annotation>
              <xs:documentation>Use the contents of the specified variable
                as the content</xs:documentation>
            </xs:annotation>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
        <xs:sequence>
          <xs:annotation>
            <xs:appinfo>
              <ncx:case-name>from-cli</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:choice>
            <xs:annotation>
              <xs:appinfo>
                <ncx:choice-name>target-parm</ncx:choice-name>
              </xs:appinfo>
            </xs:annotation>
            <xs:sequence>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:case-name>target</ncx:case-name>
                </xs:appinfo>
              </xs:annotation>
              <xs:element name="target">
                <xs:annotation>
                  <xs:documentation>XPath target object to fill.  If prefixes are missing
                    then the first match in any namespace will be used.
                    Any prefix used must be the default prefix
                    assigned to the desired YANG module. Prefix usage is
                    optional.</xs:documentation>
                  <xs:appinfo>
                    <ncx:mandatory>true</ncx:mandatory>
                    <ncx:schema-instance/>
                  </xs:appinfo>
                </xs:annotation>
                <xs:simpleType>
                  <xs:restriction base="xs:string">
                    <xs:minLength value="1"/>
                  </xs:restriction>
                </xs:simpleType>
              </xs:element>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:sequence>
            <xs:sequence>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:case-name>urltarget</ncx:case-name>
                </xs:appinfo>
              </xs:annotation>
              <xs:element name="urltarget" type="UrlPath">
                <xs:annotation>
                  <xs:documentation>URL encoded target object to fill.
                    Encoding Rules: TBD.</xs:documentation>
                  <xs:appinfo>
                    <ncx:mandatory>true</ncx:mandatory>
                  </xs:appinfo>
                </xs:annotation>
              </xs:element>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:sequence>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:choice>
          <xs:element name="optional" minOccurs="0">
            <xs:annotation>
              <xs:documentation>If present, then prompt for leafs that are optional.
                If not, skip these objects.</xs:documentation>
            </xs:annotation>
          </xs:element>
          <xs:element name="value" minOccurs="0">
            <xs:annotation>
              <xs:documentation>Contains a string representing the content
                to use for the filled variable.
                
                If a string is entered, then the target value being
                filled must be a leaf or leaf-list.
                
                If a variable is referenced, then it will
                be used as the content, if the target value being
                filled is a leaf or a leaf-list.
                
                If the target value is a complex object,
                then the referenced variable must also be
                a complex object of the same type. E.g.,
                
                The global variable 'foo' would be specified as:
                
                    value=$$foo
                
                The local variable 'bar' would be specified as:
                
                    value=$bar
                
                An error will be reported if the global or local
                variable does not reference the same object type
                as the target parameter.</xs:documentation>
            </xs:annotation>
            <xs:complexType>
              <xs:complexContent>
                <xs:extension base="xs:anyType"/>
              </xs:complexContent>
            </xs:complexType>
          </xs:element>
          <xs:element name="match-names" type="NameMatchMode"
            minOccurs="0">
            <xs:annotation>
              <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
            </xs:annotation>
          </xs:element>
          <xs:element name="alt-names" type="AltNameMode" minOccurs="0">
            <xs:annotation>
              <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
            </xs:annotation>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
        <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"
          processContents="lax"/>
      </xs:choice>
    </xs:sequence>
  </xs:group>
  <xs:group name="EditParms">
    <xs:annotation>
      <xs:documentation>Common parms for create, merge, replace commands</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:choice>
        <xs:annotation>
          <xs:appinfo>
            <ncx:choice-name>from</ncx:choice-name>
            <ncx:config>true</ncx:config>
            <ncx:mandatory>true</ncx:mandatory>
          </xs:appinfo>
        </xs:annotation>
        <xs:sequence>
          <xs:annotation>
            <xs:appinfo>
              <ncx:case-name>varref</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:element name="varref" type="xs:string" minOccurs="0">
            <xs:annotation>
              <xs:documentation>Use the contents of the specified variable
                as the content</xs:documentation>
            </xs:annotation>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
        <xs:sequence>
          <xs:annotation>
            <xs:appinfo>
              <ncx:case-name>from-cli</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:choice>
            <xs:annotation>
              <xs:appinfo>
                <ncx:choice-name>target-parm</ncx:choice-name>
              </xs:appinfo>
            </xs:annotation>
            <xs:sequence>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:case-name>target</ncx:case-name>
                </xs:appinfo>
              </xs:annotation>
              <xs:element name="target">
                <xs:annotation>
                  <xs:documentation>XPath target object to fill.  If prefixes are missing
                    then the first match in any namespace will be used.
                    Any prefix used must be the default prefix
                    assigned to the desired YANG module. Prefix usage is
                    optional.</xs:documentation>
                  <xs:appinfo>
                    <ncx:mandatory>true</ncx:mandatory>
                    <ncx:schema-instance/>
                  </xs:appinfo>
                </xs:annotation>
                <xs:simpleType>
                  <xs:restriction base="xs:string">
                    <xs:minLength value="1"/>
                  </xs:restriction>
                </xs:simpleType>
              </xs:element>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:sequence>
            <xs:sequence>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:case-name>urltarget</ncx:case-name>
                </xs:appinfo>
              </xs:annotation>
              <xs:element name="urltarget" type="UrlPath">
                <xs:annotation>
                  <xs:documentation>URL encoded target object to fill.
                    Encoding Rules: TBD.</xs:documentation>
                  <xs:appinfo>
                    <ncx:mandatory>true</ncx:mandatory>
                  </xs:appinfo>
                </xs:annotation>
              </xs:element>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:sequence>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:choice>
          <xs:element name="optional" minOccurs="0">
            <xs:annotation>
              <xs:documentation>If present, then prompt for leafs that are optional.
                If not, skip these objects.</xs:documentation>
            </xs:annotation>
          </xs:element>
          <xs:element name="value" minOccurs="0">
            <xs:annotation>
              <xs:documentation>Contains a string representing the content
                to use for the filled variable.
                
                If a string is entered, then the target value being
                filled must be a leaf or leaf-list.
                
                If a variable is referenced, then it will
                be used as the content, if the target value being
                filled is a leaf or a leaf-list.
                
                If the target value is a complex object,
                then the referenced variable must also be
                a complex object of the same type. E.g.,
                
                The global variable 'foo' would be specified as:
                
                    value=$$foo
                
                The local variable 'bar' would be specified as:
                
                    value=$bar
                
                An error will be reported if the global or local
                variable does not reference the same object type
                as the target parameter.</xs:documentation>
            </xs:annotation>
            <xs:complexType>
              <xs:complexContent>
                <xs:extension base="xs:anyType"/>
              </xs:complexContent>
            </xs:complexType>
          </xs:element>
          <xs:element name="match-names" type="NameMatchMode"
            minOccurs="0">
            <xs:annotation>
              <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
            </xs:annotation>
          </xs:element>
          <xs:element name="alt-names" type="AltNameMode" minOccurs="0">
            <xs:annotation>
              <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
            </xs:annotation>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
        <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"
          processContents="lax"/>
      </xs:choice>
      <xs:element name="timeout" type="yt:Timeout" default="30"
        minOccurs="0">
        <xs:annotation>
          <xs:documentation>Timeout to use</xs:documentation>
          <xs:appinfo>
            <ncx:units>seconds</ncx:units>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
    </xs:sequence>
  </xs:group>
  <xs:group name="SGetParms">
    <xs:annotation>
      <xs:documentation>Common parms for sget and sget-config operations.</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="nofill" minOccurs="0">
        <xs:annotation>
          <xs:documentation>If present, and the 'from-cli' option is used
            for input, then filling of mandatory nodes
            and key leafs will be skipped.  Instead, the target
            object will be treated as a terminating select node
            in the filter element.</xs:documentation>
        </xs:annotation>
      </xs:element>
    </xs:sequence>
  </xs:group>
  <xs:group name="XGetParms">
    <xs:annotation>
      <xs:documentation>Common parms for xget and xget-config operations.</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:choice>
        <xs:annotation>
          <xs:appinfo>
            <ncx:choice-name>from</ncx:choice-name>
            <ncx:mandatory>true</ncx:mandatory>
          </xs:appinfo>
        </xs:annotation>
        <xs:sequence>
          <xs:annotation>
            <xs:appinfo>
              <ncx:case-name>varref</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:element name="varref" type="xs:string" minOccurs="0">
            <xs:annotation>
              <xs:documentation>Use the contents of the specified variable
                as the content</xs:documentation>
            </xs:annotation>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
        <xs:sequence>
          <xs:annotation>
            <xs:appinfo>
              <ncx:case-name>select</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:element name="select" minOccurs="0">
            <xs:annotation>
              <xs:documentation>The XPath expression to use in the retrieval
                operation.  The string may only contain
                single quotes, which are required for
                string literals.  The entire string
                will be inserted into a double-quoted
                string, within the get-config PDU.
                Character entities will be inserted as
                needed to maintain well-formed XML.</xs:documentation>
              <xs:appinfo>
                <ncx:xpath/>
              </xs:appinfo>
            </xs:annotation>
            <xs:simpleType>
              <xs:restriction base="xs:string">
                <xs:minLength value="1"/>
              </xs:restriction>
            </xs:simpleType>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
        <xs:sequence>
          <xs:annotation>
            <xs:appinfo>
              <ncx:case-name>urltarget</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:element name="urltarget" type="UrlPath" minOccurs="0">
            <xs:annotation>
              <xs:documentation>The URL path expression to use in the retrieval
                operation.</xs:documentation>
            </xs:annotation>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
        <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"
          processContents="lax"/>
      </xs:choice>
      <xs:element name="timeout" type="yt:Timeout" default="30"
        minOccurs="0">
        <xs:annotation>
          <xs:documentation>Timeout to use</xs:documentation>
          <xs:appinfo>
            <ncx:units>seconds</ncx:units>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="match-names" type="NameMatchMode" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
          <xs:appinfo>
            <ncx:config>true</ncx:config>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="alt-names" type="AltNameMode" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
          <xs:appinfo>
            <ncx:config>true</ncx:config>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
    </xs:sequence>
  </xs:group>
  <xs:group name="ConnectParms">
    <xs:annotation>
      <xs:documentation>Common parms for connecting to a NETCONF server.
        Used by the connect operation and if present at
        the command line invocation, then the connect
        operation will be invoked automatically.</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="user" type="yt:NcxUserName" minOccurs="0">
        <xs:annotation>
          <xs:documentation>User name to use for NETCONF sessions.</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name="server" type="xs:string" minOccurs="0">
        <xs:annotation>
          <xs:documentation>IP address or DNS name of the NETCONF server target.</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name="password" type="xs:string" minOccurs="0">
        <xs:annotation>
          <xs:documentation>User password to use for NETCONF sessions.
            If none, then user will be prompted before connecting.</xs:documentation>
          <xs:appinfo>
            <ncx:password/>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="ncport" default="830" minOccurs="0">
        <xs:annotation>
          <xs:documentation>NETCONF port number to use.  If not present, then
            port 830, followed by port 22, will be tried.</xs:documentation>
        </xs:annotation>
        <xs:simpleType>
          <xs:restriction base="xs:unsignedShort">
            <xs:minInclusive value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:element>
      <xs:element name="timeout" type="yt:Timeout" default="30"
        minOccurs="0">
        <xs:annotation>
          <xs:documentation>Number of seconds to wait for a response
            from the server before declaring a timeout.
            Zero means do not timeout at all.</xs:documentation>
          <xs:appinfo>
            <ncx:units>seconds</ncx:units>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="public-key" default="$HOME/.ssh/id_rsa.pub"
        minOccurs="0">
        <xs:annotation>
          <xs:documentation>Contains the file path specification
            for the file containing the client-side public key.
            If both 'public-key' and 'private-key' files are
            present, the client will attempt to connect
            to the server using these keys.  If this fails,
            or not done, then password authentication will
            be attempted.</xs:documentation>
        </xs:annotation>
        <xs:simpleType>
          <xs:restriction base="xs:string">
            <xs:minLength value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:element>
      <xs:element name="private-key" default="$HOME/.ssh/id_rsa"
        minOccurs="0">
        <xs:annotation>
          <xs:documentation>Contains the file path specification
            for the file containing the client-side private key.
            If both 'public-key' and 'private-key' files are
            present, the client will attempt to connect
            to the server using these keys.  If this fails,
            or not done, then password authentication will
            be attempted.</xs:documentation>
        </xs:annotation>
        <xs:simpleType>
          <xs:restriction base="xs:string">
            <xs:minLength value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:element>
      <xs:element name="transport" default="ssh" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Identifies the transport protocol that should be used.</xs:documentation>
        </xs:annotation>
        <xs:simpleType>
          <xs:restriction base="xs:string">
            <xs:enumeration value="ssh">
              <xs:annotation>
                <xs:documentation>NETCONF over SSH.</xs:documentation>
                <ncx:reference>
                  <ncx:text>RFC 4742;  RFC 6242</ncx:text>
                  <ncx:url>http://www.ietf.org/rfc/rfc4742.txt</ncx:url>
                </ncx:reference>
                <xs:appinfo>
                  <ncx:value>0</ncx:value>
                </xs:appinfo>
              </xs:annotation>
            </xs:enumeration>
            <xs:enumeration value="tcp">
              <xs:annotation>
                <xs:documentation>NETCONF over TCP.
                  If this enum is selected, then the default --ncport
                  value is set to 2023, and the --protocols value
                  is set to netconf1.0.  The --password value will
                  be ignored.</xs:documentation>
                <ncx:reference>
                  <ncx:text>tail-f confd</ncx:text>
                </ncx:reference>
                <xs:appinfo>
                  <ncx:value>1</ncx:value>
                </xs:appinfo>
              </xs:annotation>
            </xs:enumeration>
          </xs:restriction>
        </xs:simpleType>
      </xs:element>
    </xs:sequence>
  </xs:group>
  <xs:group name="XPathParms">
    <xs:annotation>
      <xs:documentation>Common parameters used for XPath script constructs</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="expr">
        <xs:annotation>
          <xs:documentation>XPath expression string to evaluate.
            Use quotes if there are any whitespace or
            special characters in the expression.</xs:documentation>
          <xs:appinfo>
            <ncx:mandatory>true</ncx:mandatory>
          </xs:appinfo>
        </xs:annotation>
        <xs:simpleType>
          <xs:restriction base="yang:xpath1.0">
            <xs:minLength value="1"/>
          </xs:restriction>
        </xs:simpleType>
      </xs:element>
      <xs:element name="docroot" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Use the contents of the specified variable or
            external XML file as the conceptual document to
            apply the expression specified in the 'expr' parameter.
            
            If this parameter is missing then a dummy document
            will be used.  This is only allowed if the
            expression only contains variable references
            or numeric/string constants.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
          <xs:complexContent>
            <xs:extension base="xs:anyType"/>
          </xs:complexContent>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
  </xs:group>
  <xs:element name="yangcli">
    <xs:annotation>
      <xs:documentation>CLI Parameter Set for the NETCONF Client Application.</xs:documentation>
      <xs:appinfo>
        <ncx:config>true</ncx:config>
        <ncx:cli/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element name="aliases-file" type="xs:string"
          default="~/.yuma/.yangcli_aliases" minOccurs="0">
          <xs:annotation>
            <xs:documentation>Specifies the yangcli command aliases file to use.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="alt-names" type="AltNameMode" default="true"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="autoaliases" type="xs:boolean" default="true"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Controls whether the yangcli command aliases will
              be saved at exit and loaded at startup.
              If true, the 'aliases-file' parameter will be used if it is set,
              or else the default aliases file will be used
              (~/.yuma/.yangcli_aliases), for loading
              and saving the yangcli command aliases.
              If false, the yangcli command aliases will only be stored
              and loaded manually with the aliases command.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="autocomp" type="xs:boolean" default="true"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Controls whether partial keywords will be
              checked for interactive or script commands.
              By default, the first match for a partial keyword
              will be used if no definition is found for
              a command name or parameter name.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="autohistory" type="xs:boolean" default="true"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Controls whether the command line history buffer will
              be saved at exit and loaded at startup.
              If true, the default history file will be used
              (~/.yuma/.yangcli_history) for loading
              and saving the history buffer.
              If false, the history buffer will only be stored
              and loaded manually with the history command.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="autoload" type="xs:boolean" default="true"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Controls whether any modules (except this one)
              will be automatically loaded upon startup or
              upon session startup with a server. If false,
              the 'mgrload' command must be used to
              explicitly load all the desired YANG modules.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="autouservars" type="xs:boolean"
          default="true" minOccurs="0">
          <xs:annotation>
            <xs:documentation>Controls whether the yangcli user variables will
              be saved at exit and loaded at startup.
              If true, the 'uservars-file' parameter will be used if set,
              or else the default user variables file will be used
              (~/.yuma/yangcli_uservars.xml), for loading
              and saving the yangcli user variables.
              If false, the yangcli user variables will only be stored
              and loaded manually with the uservars command.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="bad-data" default="check" minOccurs="0">
          <xs:annotation>
            <xs:documentation>Specifies how invalid user input from the CLI
              will be handled when filling PDUs for remote
              operations.</xs:documentation>
          </xs:annotation>
          <xs:simpleType>
            <xs:restriction base="xs:string">
              <xs:enumeration value="ignore">
                <xs:annotation>
                  <xs:documentation>Silently accept invalid PDU and data model
                    parameters.  Intended for advanced server
                    testing mode only.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>0</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="warn">
                <xs:annotation>
                  <xs:documentation>Warn, but accept invalid PDU and data model
                    parameters.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>1</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="check">
                <xs:annotation>
                  <xs:documentation>Prompt the user to keep the invalid value
                    or re-enter the value.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>2</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="error">
                <xs:annotation>
                  <xs:documentation>Prompt the user to re-enter the invalid value.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>3</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        <xs:element name="batch-mode" minOccurs="0">
          <xs:annotation>
            <xs:documentation>If present, the interactive CLI will not be used.
              A script should be provided with the 'run-script'
              parameter, or a command provided with the 'run-command'
              parameter, or else the program will simply exit.
              If the auto-connect mode is enabled, then this will mode
              simply test if a NETCONF session can be established,
              then exit.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="default-module" type="yt:NcxName"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Default module name string to use before 'netconf'
              and 'yangcli' are tried.  The module prefix may need to be
              used for other modules.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="display-mode" default="plain" minOccurs="0">
          <xs:annotation>
            <xs:documentation>Controls how values are displayed during output
              to STDOUT or a log file.</xs:documentation>
          </xs:annotation>
          <xs:simpleType>
            <xs:restriction base="xs:string">
              <xs:enumeration value="plain">
                <xs:annotation>
                  <xs:documentation>Plain identifier without any prefix format.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>0</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="prefix">
                <xs:annotation>
                  <xs:documentation>Plain text with XML prefix added format.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>1</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="module">
                <xs:annotation>
                  <xs:documentation>Plain text with module name as prefix added format.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>2</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="xml">
                <xs:annotation>
                  <xs:documentation>XML format.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>3</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="xml-nons">
                <xs:annotation>
                  <xs:documentation>XML format, but no namespace (xmlns) attributes
                    will be generated.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>4</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="json">
                <xs:annotation>
                  <xs:documentation>JSON format.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>5</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        <xs:element name="echo-replies" type="xs:boolean"
          default="true" minOccurs="0">
          <xs:annotation>
            <xs:documentation>Allow RPC replies to be echoes to the log or STDOUT
              
              If 'true', &lt;rpc-reply&gt; messages containing data
              will be output to the log, if log-level is
              'info' or higher.
              
              If 'false', &lt;rpc-reply&gt; messages containing data
              will not be output to the log, regardless of
              the value of log-level.
              
              The $$echo-replies system variable is derived from
              this parameter.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="fixorder" type="xs:boolean" default="true"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Controls whether PDU parameters will be
              automatically sent to the server in the
              correct order.  If false, the specified order
              will be used. If true, then canonical order will
              be used</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="force-target" default="candidate"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Controls whether the candidate or running
              configuration datastore will be used as
              the default edit target, when both are supported
              by the server.</xs:documentation>
          </xs:annotation>
          <xs:simpleType>
            <xs:restriction base="xs:string">
              <xs:enumeration value="candidate">
                <xs:annotation>
                  <xs:documentation>Force default edit target to be candidate.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>0</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="running">
                <xs:annotation>
                  <xs:documentation>Force default edit target to be running.</xs:documentation>
                  <xs:appinfo>
                    <ncx:value>1</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        <xs:element name="match-names" type="NameMatchMode"
          default="one-nocase" minOccurs="0">
          <xs:annotation>
            <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="ncport" default="830" minOccurs="0">
          <xs:annotation>
            <xs:documentation>NETCONF port number to use.  If not present, then
              port 830, followed by port 22, will be tried.</xs:documentation>
          </xs:annotation>
          <xs:simpleType>
            <xs:restriction base="xs:unsignedShort">
              <xs:minInclusive value="1"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        <xs:element name="password" type="xs:string" minOccurs="0">
          <xs:annotation>
            <xs:documentation>User password to use for NETCONF sessions.
              If none, then user will be prompted before connecting.</xs:documentation>
            <xs:appinfo>
              <ncx:password/>
            </xs:appinfo>
          </xs:annotation>
        </xs:element>
        <xs:element name="private-key" default="$HOME/.ssh/id_rsa"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Contains the file path specification
              for the file containing the client-side private key.
              If both 'public-key' and 'private-key' files are
              present, the client will attempt to connect
              to the server using these keys.  If this fails,
              or not done, then password authentication will
              be attempted.</xs:documentation>
          </xs:annotation>
          <xs:simpleType>
            <xs:restriction base="xs:string">
              <xs:minLength value="1"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        <xs:element name="public-key" default="$HOME/.ssh/id_rsa.pub"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Contains the file path specification
              for the file containing the client-side public key.
              If both 'public-key' and 'private-key' files are
              present, the client will attempt to connect
              to the server using these keys.  If this fails,
              or not done, then password authentication will
              be attempted.</xs:documentation>
          </xs:annotation>
          <xs:simpleType>
            <xs:restriction base="xs:string">
              <xs:minLength value="1"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        <xs:choice>
          <xs:annotation>
            <xs:appinfo>
              <ncx:choice-name>run-startup-mode</ncx:choice-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:sequence>
            <xs:annotation>
              <xs:appinfo>
                <ncx:case-name>run-command</ncx:case-name>
              </xs:appinfo>
            </xs:annotation>
            <xs:element name="run-command" minOccurs="0">
              <xs:annotation>
                <xs:documentation>The specified command will be invoked upon startup.
                  If the auto-connect parameters are provided, then
                  a session will be established before running the
                  command.</xs:documentation>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="xs:string">
                  <xs:minLength value="1"/>
                  <xs:maxLength value="4095"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
          <xs:sequence>
            <xs:annotation>
              <xs:appinfo>
                <ncx:case-name>run-script</ncx:case-name>
              </xs:appinfo>
            </xs:annotation>
            <xs:element name="run-script" minOccurs="0">
              <xs:annotation>
                <xs:documentation>The specified script will be invoked upon startup.
                  If the auto-connect parameters are provided, then
                  a session will be established before running the
                  script.  If a quoted string is used, then any parameters
                  after the script name will be passed to the script.</xs:documentation>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="xs:string">
                  <xs:minLength value="1"/>
                  <xs:maxLength value="4095"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:choice>
        <xs:element name="server" type="xs:string" minOccurs="0">
          <xs:annotation>
            <xs:documentation>IP address or DNS name of the NETCONF server target.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="time-rpcs" type="xs:boolean" default="false"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Measure the round-trip time of each &lt;rpc&gt; request and
              &lt;rpc-reply&gt; at the session level.
              Echo the elapsed time value to screen if in
              interactive mode, as well as the log if the
              log is a file instead of stdout.
              The $$time-rpcs system variable is derived from this
              parameter.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="timeout" type="yt:Timeout" default="30"
          minOccurs="0">
          <xs:annotation>
            <xs:documentation>Number of seconds to wait for a response
              from the server before declaring a timeout.
              Zero means do not timeout at all.</xs:documentation>
            <xs:appinfo>
              <ncx:units>seconds</ncx:units>
            </xs:appinfo>
          </xs:annotation>
        </xs:element>
        <xs:element name="transport" default="ssh" minOccurs="0">
          <xs:annotation>
            <xs:documentation>Identifies the transport protocol that should be used.</xs:documentation>
          </xs:annotation>
          <xs:simpleType>
            <xs:restriction base="xs:string">
              <xs:enumeration value="ssh">
                <xs:annotation>
                  <xs:documentation>NETCONF over SSH.</xs:documentation>
                  <ncx:reference>
                    <ncx:text>RFC 4742;  RFC 6242</ncx:text>
                    <ncx:url>http://www.ietf.org/rfc/rfc4742.txt</ncx:url>
                  </ncx:reference>
                  <xs:appinfo>
                    <ncx:value>0</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
              <xs:enumeration value="tcp">
                <xs:annotation>
                  <xs:documentation>NETCONF over TCP.
                    If this enum is selected, then the default --ncport
                    value is set to 2023, and the --protocols value
                    is set to netconf1.0.  The --password value will
                    be ignored.</xs:documentation>
                  <ncx:reference>
                    <ncx:text>tail-f confd</ncx:text>
                  </ncx:reference>
                  <xs:appinfo>
                    <ncx:value>1</ncx:value>
                  </xs:appinfo>
                </xs:annotation>
              </xs:enumeration>
            </xs:restriction>
          </xs:simpleType>
        </xs:element>
        <xs:element name="use-xmlheader" type="xs:boolean"
          default="true" minOccurs="0">
          <xs:annotation>
            <xs:documentation>Specifies how file result variables will be written
              for XML files.  Controls whether the XML preamble
              header will be written or not.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="user" type="yt:NcxUserName" minOccurs="0">
          <xs:annotation>
            <xs:documentation>User name to use for NETCONF sessions.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:element name="uservars-file" type="xs:string"
          default="~/.yuma/yangcli_uservars.xml" minOccurs="0">
          <xs:annotation>
            <xs:documentation>Specifies the yangcli user variables file to use.</xs:documentation>
          </xs:annotation>
        </xs:element>
        <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"
          processContents="lax"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="alias_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="alias" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Show or set a specific yangcli command alias.
        
        * Show all aliases in memory (same as aliases):
        
          yangcli&gt;  alias
        
        * Show one alias 'foo':
        
          yangcli&gt;  alias foo
        
        * Set one alias; make sure there is no whitespace
          between the '=' char and either string.  If the value
          has whitespace, it must be quoted. If the equals sign
          is present, then a valid value string must be present.
        
          Quotes will be preserved if used:
            * Single quotes can appear within doubled-quoted
              strings but not any double quotes.
            * Double quotes can appear within single-quoted strings
              but not any single quotes.
        
          The first token in a plain command or the first token
          in the right-hand-side expression in an assignment
          statement can be an alias.
        
          The alias name must exact match the token.
          A new command line will be constructed replacing
          the alias name with its value.  The new command
          line will then be parsed as usual.
        
          yangcli&gt;  alias s=show
          yangcli&gt;  alias getfoo='sget-config source=running /top/foo'
        
        * Aliases can override real commands, so be careful
         not to unintentionally alter real commands.
        
          yangcli&gt;  alias get-config='get-config source=running'
        </xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>alias_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>var</ncx:parm>
          </ncx:default-parm>
          <ncx:default-parm-equals-ok/>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="var" minOccurs="0">
              <xs:annotation>
                <xs:documentation>The alias command string.</xs:documentation>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="xs:string">
                  <xs:minLength value="1"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="aliases_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="aliases" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Manage the yangcli command aliases</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>aliases_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>alias-action</ncx:choice-name>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>show</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="show" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show all the yangcli command aliases.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>clear</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="clear" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Delete all the yangcli aliases from memory.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>load</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="load" type="xs:string"
                  default="~/.yuma/.yangcli_aliases" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Load the yangcli command aliases from the
                      specified file spec.  The default aliases
                      file will be loaded automatically at startup
                      if the '--autoaliases' parameter is present.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>save</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="save" type="xs:string"
                  default="~/.yuma/.yangcli_aliases" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Save the yangcli command aliases to the
                      specified filespec. The default aliases
                      file will be saved automatically at shutdown
                      if the '--autoaliases' parameter is present.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="cd_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="cd" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Change the current working directory.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>cd_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>dir</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="dir" type="xs:string">
              <xs:annotation>
                <xs:documentation>Directory path to use.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="connect_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="connect" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Connect to a NETCONF server.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>connect_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>server</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="user" type="yt:NcxUserName">
              <xs:annotation>
                <xs:documentation>User name to use for NETCONF sessions.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="server" type="xs:string">
              <xs:annotation>
                <xs:documentation>IP address or DNS name of the NETCONF server target.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="password" type="xs:string">
              <xs:annotation>
                <xs:documentation>User password to use for NETCONF sessions.
                  If none, then user will be prompted before connecting.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                  <ncx:password/>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="ncport" default="830" minOccurs="0">
              <xs:annotation>
                <xs:documentation>NETCONF port number to use.  If not present, then
                  port 830, followed by port 22, will be tried.</xs:documentation>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="xs:unsignedShort">
                  <xs:minInclusive value="1"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:element name="timeout" type="yt:Timeout" default="30"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Number of seconds to wait for a response
                  from the server before declaring a timeout.
                  Zero means do not timeout at all.</xs:documentation>
                <xs:appinfo>
                  <ncx:units>seconds</ncx:units>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="public-key"
              default="$HOME/.ssh/id_rsa.pub" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Contains the file path specification
                  for the file containing the client-side public key.
                  If both 'public-key' and 'private-key' files are
                  present, the client will attempt to connect
                  to the server using these keys.  If this fails,
                  or not done, then password authentication will
                  be attempted.</xs:documentation>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="xs:string">
                  <xs:minLength value="1"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:element name="private-key" default="$HOME/.ssh/id_rsa"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Contains the file path specification
                  for the file containing the client-side private key.
                  If both 'public-key' and 'private-key' files are
                  present, the client will attempt to connect
                  to the server using these keys.  If this fails,
                  or not done, then password authentication will
                  be attempted.</xs:documentation>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="xs:string">
                  <xs:minLength value="1"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:element name="transport" default="ssh" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Identifies the transport protocol that should be used.</xs:documentation>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="xs:string">
                  <xs:enumeration value="ssh">
                    <xs:annotation>
                      <xs:documentation>NETCONF over SSH.</xs:documentation>
                      <ncx:reference>
                        <ncx:text>RFC 4742;  RFC 6242</ncx:text>
                        <ncx:url>http://www.ietf.org/rfc/rfc4742.txt</ncx:url>
                      </ncx:reference>
                      <xs:appinfo>
                        <ncx:value>0</ncx:value>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:enumeration>
                  <xs:enumeration value="tcp">
                    <xs:annotation>
                      <xs:documentation>NETCONF over TCP.
                        If this enum is selected, then the default --ncport
                        value is set to 2023, and the --protocols value
                        is set to netconf1.0.  The --password value will
                        be ignored.</xs:documentation>
                      <ncx:reference>
                        <ncx:text>tail-f confd</ncx:text>
                      </ncx:reference>
                      <xs:appinfo>
                        <ncx:value>1</ncx:value>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:enumeration>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="create_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="create" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Create some NETCONF config data with the edit-config operation</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>create_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>target</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>from</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>varref</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="varref" type="xs:string"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Use the contents of the specified variable
                      as the content</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>from-cli</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:choice>
                  <xs:annotation>
                    <xs:appinfo>
                      <ncx:choice-name>target-parm</ncx:choice-name>
                    </xs:appinfo>
                  </xs:annotation>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>target</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="target">
                      <xs:annotation>
                        <xs:documentation>XPath target object to fill.  If prefixes are missing
                          then the first match in any namespace will be used.
                          Any prefix used must be the default prefix
                          assigned to the desired YANG module. Prefix usage is
                          optional.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                          <ncx:schema-instance/>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:simpleType>
                        <xs:restriction base="xs:string">
                          <xs:minLength value="1"/>
                        </xs:restriction>
                      </xs:simpleType>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>urltarget</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="urltarget" type="UrlPath">
                      <xs:annotation>
                        <xs:documentation>URL encoded target object to fill.
                          Encoding Rules: TBD.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                        </xs:appinfo>
                      </xs:annotation>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded"
                    namespace="##other" processContents="lax"/>
                </xs:choice>
                <xs:element name="optional" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>If present, then prompt for leafs that are optional.
                      If not, skip these objects.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="value" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains a string representing the content
                      to use for the filled variable.
                      
                      If a string is entered, then the target value being
                      filled must be a leaf or leaf-list.
                      
                      If a variable is referenced, then it will
                      be used as the content, if the target value being
                      filled is a leaf or a leaf-list.
                      
                      If the target value is a complex object,
                      then the referenced variable must also be
                      a complex object of the same type. E.g.,
                      
                      The global variable 'foo' would be specified as:
                      
                          value=$$foo
                      
                      The local variable 'bar' would be specified as:
                      
                          value=$bar
                      
                      An error will be reported if the global or local
                      variable does not reference the same object type
                      as the target parameter.</xs:documentation>
                  </xs:annotation>
                  <xs:complexType>
                    <xs:complexContent>
                      <xs:extension base="xs:anyType"/>
                    </xs:complexContent>
                  </xs:complexType>
                </xs:element>
                <xs:element name="match-names" type="NameMatchMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="alt-names" type="AltNameMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:element name="timeout" type="yt:Timeout" default="30"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Timeout to use</xs:documentation>
                <xs:appinfo>
                  <ncx:units>seconds</ncx:units>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="delete_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="delete" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Delete some NETCONF config data with the edit-config operation</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>delete_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>target</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>delete-target</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>target</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="target" type="xs:string"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Xpath expression indicating the node which is going
                      to be deleted.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>urltarget</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="urltarget" type="UrlPath"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>The URL path expression to use in the delete
                      operation.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="elif_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="elif" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Evaluate an XPath expression locally on the manager.
        and execute the block of commands that follow
        if the expression is true.  The block ends
        when a matching 'elif', 'else', or 'end' command is reached.
        This may only be used after an 'if' or 'elif' command
        or an error (no matching if command) will occur.
        </xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>elif_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>expr</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="expr">
              <xs:annotation>
                <xs:documentation>XPath expression string to evaluate.
                  Use quotes if there are any whitespace or
                  special characters in the expression.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="yang:xpath1.0">
                  <xs:minLength value="1"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:element name="docroot" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Use the contents of the specified variable or
                  external XML file as the conceptual document to
                  apply the expression specified in the 'expr' parameter.
                  
                  If this parameter is missing then a dummy document
                  will be used.  This is only allowed if the
                  expression only contains variable references
                  or numeric/string constants.</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:complexContent>
                  <xs:extension base="xs:anyType"/>
                </xs:complexContent>
              </xs:complexType>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="else_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="else" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>End an 'if' or 'elif' command block, and start a new
        command block that must end with an 'end' command.
        If no 'if' or 'elif' block is in progress then an error
        will occur.
        </xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>else_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="end_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="end" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>End an 'if' command block or a 'while' command block.
        If no block is in progress then an error will occur.
        </xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>end_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="eval_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:element name="data" minOccurs="0">
            <xs:annotation>
              <xs:documentation>The XPath result, returned in a data element.
                
                The content will be a simple string for boolean, string,
                and number result types.
                
                The content will be zero or more child elements,
                in their proper namespaces, if the result is a node-set.
                Only the requested node(s) will be returned,
                not their entire path to the document root,
                like the get and get-config operations.
                
                An empty 'data' element will be returned if the result
                is an empty node-set.</xs:documentation>
              <xs:appinfo>
                <ncx:mandatory>true</ncx:mandatory>
              </xs:appinfo>
            </xs:annotation>
            <xs:complexType>
              <xs:complexContent>
                <xs:extension base="xs:anyType"/>
              </xs:complexContent>
            </xs:complexType>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="eval" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Evaluate an XPath expression locally on the manager.
        All local variables will be available to the session
        context, in the following precedence:
           1) current script run level
           2) global variable
        
        When the result of an eval command is saved
        to a user variable, it may be altered as follows:
        
          Convert to string:
           - &lt;data&gt; is a simple type
           - &lt;data&gt; contains 1 node that is a simple type
        
          Remove the &lt;data&gt; container:
           - &lt;data&gt; contains a single complex element
        
          Retain the &lt;data&gt; container:
           - &lt;data&gt; contains multiple elements
        
        Usage Examples:
        
        &gt; $x = 5
            x = '5'
        &gt; $x = eval '$x + 10'
            x = '15'
        &gt; $y = xget /system
            y = data {
        	  system { ... }
        	}
        &gt; $z = eval '//sysname' docroot=$y
            z = 'Linux'
        &gt; $w = eval '/system/uname' docroot=$y
            w = uname {
        	  sysname 'Linux'
        	  ...
        	}
        </xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>eval_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>expr</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="expr">
              <xs:annotation>
                <xs:documentation>XPath expression string to evaluate.
                  Use quotes if there are any whitespace or
                  special characters in the expression.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="yang:xpath1.0">
                  <xs:minLength value="1"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:element name="docroot" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Use the contents of the specified variable or
                  external XML file as the conceptual document to
                  apply the expression specified in the 'expr' parameter.
                  
                  If this parameter is missing then a dummy document
                  will be used.  This is only allowed if the
                  expression only contains variable references
                  or numeric/string constants.</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:complexContent>
                  <xs:extension base="xs:anyType"/>
                </xs:complexContent>
              </xs:complexType>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="eventlog_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="eventlog" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Access the notification event log</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>eventlog_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>show</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>eventlog-action</ncx:choice-name>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>show-case</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="show" type="LogCount" default="-1"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show the specified number of event log
                      buffer entries. -1 means show all entries.
                      If the --full or --brief help-mode parameters
                      are entered, then the output will be altered.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="start" type="LogIndex" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Start at the specified event index number instead of
                      the beginning of the event log.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>clear</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="clear" type="LogCount" default="25"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Clear the specified number of notification
                      event log entries.  The value zero means
                      clear all the entries.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="fill_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:element name="data" minOccurs="0">
            <xs:annotation>
              <xs:documentation>The result of the fill operation.
                
                The name of the value node may not really
                be 'data'. If the 'target' or 'current-value'
                input parameters are used, then the name
                of the result node will be copied instead.
                
                The data type will be inherited from the 'target'
                or 'current_value' parameters, and not really be
                an 'anyxml' structure.  YANG does have a data
                type that supports this feature.</xs:documentation>
            </xs:annotation>
            <xs:complexType>
              <xs:complexContent>
                <xs:extension base="xs:anyType"/>
              </xs:complexContent>
            </xs:complexType>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="fill" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Fill a value for reuse in a NETCONF PDU or other operation.
        
        Used in an assignment statement to create a variable
        for later use:
        
            $foo = fill --target=/t:foo-con/bar-list \
        		--optional \
        		--current-value=$bar    </xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>fill_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>target</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>target-parm</ncx:choice-name>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>target</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="target">
                  <xs:annotation>
                    <xs:documentation>XPath target object to fill.  If prefixes are missing
                      then the first match in any namespace will be used.
                      Any prefix used must be the default prefix
                      assigned to the desired YANG module. Prefix usage is
                      optional.</xs:documentation>
                    <xs:appinfo>
                      <ncx:mandatory>true</ncx:mandatory>
                      <ncx:schema-instance/>
                    </xs:appinfo>
                  </xs:annotation>
                  <xs:simpleType>
                    <xs:restriction base="xs:string">
                      <xs:minLength value="1"/>
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>urltarget</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="urltarget" type="UrlPath">
                  <xs:annotation>
                    <xs:documentation>URL encoded target object to fill.
                      Encoding Rules: TBD.</xs:documentation>
                    <xs:appinfo>
                      <ncx:mandatory>true</ncx:mandatory>
                    </xs:appinfo>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:element name="optional" minOccurs="0">
              <xs:annotation>
                <xs:documentation>If present, then prompt for leafs that are optional.
                  If not, skip these objects.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="value" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Contains a string representing the content
                  to use for the filled variable.
                  
                  If a string is entered, then the target value being
                  filled must be a leaf or leaf-list.
                  
                  If a variable is referenced, then it will
                  be used as the content, if the target value being
                  filled is a leaf or a leaf-list.
                  
                  If the target value is a complex object,
                  then the referenced variable must also be
                  a complex object of the same type. E.g.,
                  
                  The global variable 'foo' would be specified as:
                  
                      value=$$foo
                  
                  The local variable 'bar' would be specified as:
                  
                      value=$bar
                  
                  An error will be reported if the global or local
                  variable does not reference the same object type
                  as the target parameter.</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:complexContent>
                  <xs:extension base="xs:anyType"/>
                </xs:complexContent>
              </xs:complexType>
            </xs:element>
            <xs:element name="match-names" type="NameMatchMode"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="alt-names" type="AltNameMode"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="get-locks_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="get-locks" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Get a lock for the running configuration
        and the candidate and startup configurations,
        if needed.  If all the locks cannot be obtained,
        then release all of them (all-or-nothing).
        The entire operation must be completed within
        the lock timeout interval, if it is set.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>get-locks_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="lock-timeout" type="yt:Timeout"
              default="120" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Total time to wait to retrieve all the locks needed
                  to complete the get-locks command.  A value of zero
                  means to wait forever and not use a timeout value.</xs:documentation>
                <xs:appinfo>
                  <ncx:units>seconds</ncx:units>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="retry-interval" default="2" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Retry interval to use if a lock is temporarily
                  unavailable.  The client will wait this number of
                  seconds before attempting to get the current lock.</xs:documentation>
                <xs:appinfo>
                  <ncx:units>seconds</ncx:units>
                </xs:appinfo>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="xs:unsignedInt">
                  <xs:minInclusive value="1"/>
                  <xs:maxInclusive value="300"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:element name="cleanup" type="xs:boolean" default="true"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Indicates whether the locks obtained should be
                  automatically released if an RPC operation
                  fails (after the get-locks succeeds).</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="help_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="help" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Print the yangcli help text</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>help_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>command</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>helptype</ncx:choice-name>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>command</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="command" type="yt:NcxIdentifier"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show help for the specified command,
                      also called an RPC method</xs:documentation>
                  </xs:annotation>
                  <xs:simpleType>
                    <xs:union memberTypes="yt:NcxName&#32;yt:NcxQName"/>
                  </xs:simpleType>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>commands</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="commands" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show info for all local commands</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>notification</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="notification" type="yt:NcxIdentifier"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show help for the specified notification</xs:documentation>
                  </xs:annotation>
                  <xs:simpleType>
                    <xs:union memberTypes="yt:NcxName&#32;yt:NcxQName"/>
                  </xs:simpleType>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>object</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="object" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show help for the specified object</xs:documentation>
                  </xs:annotation>
                  <xs:simpleType>
                    <xs:union memberTypes="yt:NcxIdentifier&#32;UrlPath"/>
                  </xs:simpleType>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>type</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="type" type="yt:NcxIdentifier"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show help for the specified type</xs:documentation>
                  </xs:annotation>
                  <xs:simpleType>
                    <xs:union memberTypes="yt:NcxName&#32;yt:NcxQName"/>
                  </xs:simpleType>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="history_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="history" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Access the command line history buffer</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>history_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>show</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>history-action</ncx:choice-name>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>show-case</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="show" type="LogCount" default="25"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show the specified number of history
                      buffer entries. -1 means show all entries.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>clear</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="clear" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Clear all the history buffer entries.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>load</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="load" type="xs:string"
                  default="~/.yuma/.yangcli_history" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Load the command history buffer from the
                      specified file spec.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>save</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="save" type="xs:string"
                  default="~/.yuma/.yangcli_history" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Save the command history buffer in the
                      specified filespec.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="if_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="if" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Evaluate an XPath expression locally on the manager.
        and execute the block of commands that follow
        if the expression is true.  The block ends
        when a matching 'elif', 'else', or 'end' command is reached.
        </xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>if_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>expr</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="expr">
              <xs:annotation>
                <xs:documentation>XPath expression string to evaluate.
                  Use quotes if there are any whitespace or
                  special characters in the expression.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="yang:xpath1.0">
                  <xs:minLength value="1"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:element name="docroot" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Use the contents of the specified variable or
                  external XML file as the conceptual document to
                  apply the expression specified in the 'expr' parameter.
                  
                  If this parameter is missing then a dummy document
                  will be used.  This is only allowed if the
                  expression only contains variable references
                  or numeric/string constants.</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:complexContent>
                  <xs:extension base="xs:anyType"/>
                </xs:complexContent>
              </xs:complexType>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="insert_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="insert" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Insert some NETCONF config data with the edit-config operation</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>insert_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>target</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>from</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>varref</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="varref" type="xs:string"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Use the contents of the specified variable
                      as the content</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>from-cli</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:choice>
                  <xs:annotation>
                    <xs:appinfo>
                      <ncx:choice-name>target-parm</ncx:choice-name>
                    </xs:appinfo>
                  </xs:annotation>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>target</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="target">
                      <xs:annotation>
                        <xs:documentation>XPath target object to fill.  If prefixes are missing
                          then the first match in any namespace will be used.
                          Any prefix used must be the default prefix
                          assigned to the desired YANG module. Prefix usage is
                          optional.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                          <ncx:schema-instance/>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:simpleType>
                        <xs:restriction base="xs:string">
                          <xs:minLength value="1"/>
                        </xs:restriction>
                      </xs:simpleType>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>urltarget</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="urltarget" type="UrlPath">
                      <xs:annotation>
                        <xs:documentation>URL encoded target object to fill.
                          Encoding Rules: TBD.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                        </xs:appinfo>
                      </xs:annotation>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded"
                    namespace="##other" processContents="lax"/>
                </xs:choice>
                <xs:element name="optional" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>If present, then prompt for leafs that are optional.
                      If not, skip these objects.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="value" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains a string representing the content
                      to use for the filled variable.
                      
                      If a string is entered, then the target value being
                      filled must be a leaf or leaf-list.
                      
                      If a variable is referenced, then it will
                      be used as the content, if the target value being
                      filled is a leaf or a leaf-list.
                      
                      If the target value is a complex object,
                      then the referenced variable must also be
                      a complex object of the same type. E.g.,
                      
                      The global variable 'foo' would be specified as:
                      
                          value=$$foo
                      
                      The local variable 'bar' would be specified as:
                      
                          value=$bar
                      
                      An error will be reported if the global or local
                      variable does not reference the same object type
                      as the target parameter.</xs:documentation>
                  </xs:annotation>
                  <xs:complexType>
                    <xs:complexContent>
                      <xs:extension base="xs:anyType"/>
                    </xs:complexContent>
                  </xs:complexType>
                </xs:element>
                <xs:element name="match-names" type="NameMatchMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="alt-names" type="AltNameMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:element name="timeout" type="yt:Timeout" default="30"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Timeout to use</xs:documentation>
                <xs:appinfo>
                  <ncx:units>seconds</ncx:units>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="order" default="last" minOccurs="0">
              <xs:annotation>
                <xs:documentation>The insert order that should be used.
                  If the values 'before' or 'after' are selected,
                  then the edit-target parameter must also be present.</xs:documentation>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="xs:string">
                  <xs:enumeration value="first">
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:value>0</ncx:value>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:enumeration>
                  <xs:enumeration value="last">
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:value>1</ncx:value>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:enumeration>
                  <xs:enumeration value="before">
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:value>2</ncx:value>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:enumeration>
                  <xs:enumeration value="after">
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:value>3</ncx:value>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:enumeration>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:element name="operation" default="merge" minOccurs="0">
              <xs:annotation>
                <xs:documentation>The edit-config operation that should be used.</xs:documentation>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="xs:string">
                  <xs:enumeration value="create">
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:value>0</ncx:value>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:enumeration>
                  <xs:enumeration value="merge">
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:value>1</ncx:value>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:enumeration>
                  <xs:enumeration value="replace">
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:value>2</ncx:value>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:enumeration>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:element name="edit-target" type="xs:string"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>The value or key clause that should be used.
                  This parameter should only be present if the
                  order selected is 'before' or 'after'.
                  
                  For a leaf-list, the edit-target contains the
                  value of the target leaf-list node within the
                  configuration being edited.  The new config
                  will be inserted before or after this leaf-list
                  node, depending on the order selected.
                  E.g., edit-target='some leaf content'.
                  
                  For a list, the edit-target contains the
                  key values of the target list node within the
                  configuration being edited.  The new config
                  will be inserted before or after this list
                  node, depending on the order selected.
                  E.g., edit-target=[name='fred'][zipcode=90210].</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="list_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="list" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>List some NETCONF info.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>list_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>listtype</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>commands</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="commands" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>List all local and remote commands</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>files</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="files" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>List all available data files.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>objects</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="objects" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>List all available top-level object names.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>oids</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="oids" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>List all available object identifiers.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>modules</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="modules" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>List all available local YANG files.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>scripts</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="scripts" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>List all available script files.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:element name="module" type="yt:NcxIdentifier"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>List only from this module, if specified.</xs:documentation>
              </xs:annotation>
              <xs:simpleType>
                <xs:union memberTypes="yt:NcxName&#32;yt:NcxQName"/>
              </xs:simpleType>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="log-error_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="log-error" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Write a message to the output log if the log-level
        is greater or equal to 'error'.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>log-error_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>msg</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="msg" type="xs:string">
              <xs:annotation>
                <xs:documentation>The formatted text string to write to the log.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="log-warn_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="log-warn" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Write a message to the output log if the log-level
        is greater or equal to 'warn'.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>log-warn_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>msg</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="msg" type="xs:string">
              <xs:annotation>
                <xs:documentation>The formatted text string to write to the log.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="log-info_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="log-info" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Write a message to the output log if the log-level
        is greater or equal to 'info'.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>log-info_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>msg</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="msg" type="xs:string">
              <xs:annotation>
                <xs:documentation>The formatted text string to write to the log.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="log-debug_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="log-debug" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Write a message to the output log if the log-level
        is greater or equal to 'debug'.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>log-debug_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>msg</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="msg" type="xs:string">
              <xs:annotation>
                <xs:documentation>The formatted text string to write to the log.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="merge_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="merge" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Merge some NETCONF config data with the edit-config operation</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>merge_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>target</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>from</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>varref</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="varref" type="xs:string"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Use the contents of the specified variable
                      as the content</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>from-cli</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:choice>
                  <xs:annotation>
                    <xs:appinfo>
                      <ncx:choice-name>target-parm</ncx:choice-name>
                    </xs:appinfo>
                  </xs:annotation>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>target</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="target">
                      <xs:annotation>
                        <xs:documentation>XPath target object to fill.  If prefixes are missing
                          then the first match in any namespace will be used.
                          Any prefix used must be the default prefix
                          assigned to the desired YANG module. Prefix usage is
                          optional.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                          <ncx:schema-instance/>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:simpleType>
                        <xs:restriction base="xs:string">
                          <xs:minLength value="1"/>
                        </xs:restriction>
                      </xs:simpleType>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>urltarget</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="urltarget" type="UrlPath">
                      <xs:annotation>
                        <xs:documentation>URL encoded target object to fill.
                          Encoding Rules: TBD.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                        </xs:appinfo>
                      </xs:annotation>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded"
                    namespace="##other" processContents="lax"/>
                </xs:choice>
                <xs:element name="optional" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>If present, then prompt for leafs that are optional.
                      If not, skip these objects.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="value" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains a string representing the content
                      to use for the filled variable.
                      
                      If a string is entered, then the target value being
                      filled must be a leaf or leaf-list.
                      
                      If a variable is referenced, then it will
                      be used as the content, if the target value being
                      filled is a leaf or a leaf-list.
                      
                      If the target value is a complex object,
                      then the referenced variable must also be
                      a complex object of the same type. E.g.,
                      
                      The global variable 'foo' would be specified as:
                      
                          value=$$foo
                      
                      The local variable 'bar' would be specified as:
                      
                          value=$bar
                      
                      An error will be reported if the global or local
                      variable does not reference the same object type
                      as the target parameter.</xs:documentation>
                  </xs:annotation>
                  <xs:complexType>
                    <xs:complexContent>
                      <xs:extension base="xs:anyType"/>
                    </xs:complexContent>
                  </xs:complexType>
                </xs:element>
                <xs:element name="match-names" type="NameMatchMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="alt-names" type="AltNameMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:element name="timeout" type="yt:Timeout" default="30"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Timeout to use</xs:documentation>
                <xs:appinfo>
                  <ncx:units>seconds</ncx:units>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="mgrload_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="mgrload" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Load a module or other file into the client.
        Use the 'load' command to load a module into
        the server.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>mgrload_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>module</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="module" type="yt:NcxName">
              <xs:annotation>
                <xs:documentation>Module name to load</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="revision" type="yt:Date" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Module revision to load.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="pwd_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="pwd" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Print the current working directory.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>pwd_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="replace_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="replace" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Create some NETCONF config data with the edit-config operation</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>replace_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>target</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>from</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>varref</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="varref" type="xs:string"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Use the contents of the specified variable
                      as the content</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>from-cli</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:choice>
                  <xs:annotation>
                    <xs:appinfo>
                      <ncx:choice-name>target-parm</ncx:choice-name>
                    </xs:appinfo>
                  </xs:annotation>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>target</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="target">
                      <xs:annotation>
                        <xs:documentation>XPath target object to fill.  If prefixes are missing
                          then the first match in any namespace will be used.
                          Any prefix used must be the default prefix
                          assigned to the desired YANG module. Prefix usage is
                          optional.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                          <ncx:schema-instance/>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:simpleType>
                        <xs:restriction base="xs:string">
                          <xs:minLength value="1"/>
                        </xs:restriction>
                      </xs:simpleType>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>urltarget</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="urltarget" type="UrlPath">
                      <xs:annotation>
                        <xs:documentation>URL encoded target object to fill.
                          Encoding Rules: TBD.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                        </xs:appinfo>
                      </xs:annotation>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded"
                    namespace="##other" processContents="lax"/>
                </xs:choice>
                <xs:element name="optional" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>If present, then prompt for leafs that are optional.
                      If not, skip these objects.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="value" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains a string representing the content
                      to use for the filled variable.
                      
                      If a string is entered, then the target value being
                      filled must be a leaf or leaf-list.
                      
                      If a variable is referenced, then it will
                      be used as the content, if the target value being
                      filled is a leaf or a leaf-list.
                      
                      If the target value is a complex object,
                      then the referenced variable must also be
                      a complex object of the same type. E.g.,
                      
                      The global variable 'foo' would be specified as:
                      
                          value=$$foo
                      
                      The local variable 'bar' would be specified as:
                      
                          value=$bar
                      
                      An error will be reported if the global or local
                      variable does not reference the same object type
                      as the target parameter.</xs:documentation>
                  </xs:annotation>
                  <xs:complexType>
                    <xs:complexContent>
                      <xs:extension base="xs:anyType"/>
                    </xs:complexContent>
                  </xs:complexType>
                </xs:element>
                <xs:element name="match-names" type="NameMatchMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="alt-names" type="AltNameMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:element name="timeout" type="yt:Timeout" default="30"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Timeout to use</xs:documentation>
                <xs:appinfo>
                  <ncx:units>seconds</ncx:units>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="quit_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="quit" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Quit the yangcli application</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>quit_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="recall_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="recall" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Recall the specified command line history
        buffer entry into the current command line.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>recall_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>index</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="index" type="LogIndex">
              <xs:annotation>
                <xs:documentation>Index [0..N] of the command line
                  history entry to recall.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="release-locks_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="release-locks" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Unlock all the server databases that were
        previously locked with the get-locks command.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>release-locks_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="remove_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="remove" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Remove some NETCONF config data with the edit-config operation</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>remove_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>target</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="target" type="xs:string">
              <xs:annotation>
                <xs:documentation>Xpath expression indicating the node which is going
                  to be deleted.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="run_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="run" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Internal command to run a script.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>run_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>script</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="script" type="xs:string">
              <xs:annotation>
                <xs:documentation>script filespec to run</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="P1" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>script parameter $1</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="P2" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>script parameter $2</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="P3" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>script parameter $3</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="P4" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>script parameter $4</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="P5" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>script parameter $5</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="P6" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>script parameter $6</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="P7" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>script parameter $7</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="P8" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>script parameter $8</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="P9" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>script parameter $9</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="save_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="save" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Meta command to save configuration edits.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>save_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="sget_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:element name="data" minOccurs="0">
            <xs:annotation>
              <xs:documentation>The data resulting from the retrieval operation.</xs:documentation>
            </xs:annotation>
            <xs:complexType>
              <xs:complexContent>
                <xs:extension base="xs:anyType"/>
              </xs:complexContent>
            </xs:complexType>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="sget" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Get some NETCONF running config or state data with the get
        operation, using an optional subtree filter.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>sget_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>target</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>from</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>varref</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="varref" type="xs:string"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Use the contents of the specified variable
                      as the content</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>from-cli</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:choice>
                  <xs:annotation>
                    <xs:appinfo>
                      <ncx:choice-name>target-parm</ncx:choice-name>
                    </xs:appinfo>
                  </xs:annotation>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>target</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="target">
                      <xs:annotation>
                        <xs:documentation>XPath target object to fill.  If prefixes are missing
                          then the first match in any namespace will be used.
                          Any prefix used must be the default prefix
                          assigned to the desired YANG module. Prefix usage is
                          optional.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                          <ncx:schema-instance/>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:simpleType>
                        <xs:restriction base="xs:string">
                          <xs:minLength value="1"/>
                        </xs:restriction>
                      </xs:simpleType>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>urltarget</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="urltarget" type="UrlPath">
                      <xs:annotation>
                        <xs:documentation>URL encoded target object to fill.
                          Encoding Rules: TBD.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                        </xs:appinfo>
                      </xs:annotation>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded"
                    namespace="##other" processContents="lax"/>
                </xs:choice>
                <xs:element name="optional" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>If present, then prompt for leafs that are optional.
                      If not, skip these objects.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="value" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains a string representing the content
                      to use for the filled variable.
                      
                      If a string is entered, then the target value being
                      filled must be a leaf or leaf-list.
                      
                      If a variable is referenced, then it will
                      be used as the content, if the target value being
                      filled is a leaf or a leaf-list.
                      
                      If the target value is a complex object,
                      then the referenced variable must also be
                      a complex object of the same type. E.g.,
                      
                      The global variable 'foo' would be specified as:
                      
                          value=$$foo
                      
                      The local variable 'bar' would be specified as:
                      
                          value=$bar
                      
                      An error will be reported if the global or local
                      variable does not reference the same object type
                      as the target parameter.</xs:documentation>
                  </xs:annotation>
                  <xs:complexType>
                    <xs:complexContent>
                      <xs:extension base="xs:anyType"/>
                    </xs:complexContent>
                  </xs:complexType>
                </xs:element>
                <xs:element name="match-names" type="NameMatchMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="alt-names" type="AltNameMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:element name="nofill" minOccurs="0">
              <xs:annotation>
                <xs:documentation>If present, and the 'from-cli' option is used
                  for input, then filling of mandatory nodes
                  and key leafs will be skipped.  Instead, the target
                  object will be treated as a terminating select node
                  in the filter element.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="sget-config_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:element name="data" minOccurs="0">
            <xs:annotation>
              <xs:documentation>The data resulting from the retrieval operation.</xs:documentation>
            </xs:annotation>
            <xs:complexType>
              <xs:complexContent>
                <xs:extension base="xs:anyType"/>
              </xs:complexContent>
            </xs:complexType>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="sget-config" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Get some NETCONF config data with the get-config
        operation, using an optional subtree filter.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>sget-config_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>target</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>from</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>varref</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="varref" type="xs:string"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Use the contents of the specified variable
                      as the content</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>from-cli</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:choice>
                  <xs:annotation>
                    <xs:appinfo>
                      <ncx:choice-name>target-parm</ncx:choice-name>
                    </xs:appinfo>
                  </xs:annotation>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>target</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="target">
                      <xs:annotation>
                        <xs:documentation>XPath target object to fill.  If prefixes are missing
                          then the first match in any namespace will be used.
                          Any prefix used must be the default prefix
                          assigned to the desired YANG module. Prefix usage is
                          optional.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                          <ncx:schema-instance/>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:simpleType>
                        <xs:restriction base="xs:string">
                          <xs:minLength value="1"/>
                        </xs:restriction>
                      </xs:simpleType>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:sequence>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:case-name>urltarget</ncx:case-name>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:element name="urltarget" type="UrlPath">
                      <xs:annotation>
                        <xs:documentation>URL encoded target object to fill.
                          Encoding Rules: TBD.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                        </xs:appinfo>
                      </xs:annotation>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                  <xs:any minOccurs="0" maxOccurs="unbounded"
                    namespace="##other" processContents="lax"/>
                </xs:choice>
                <xs:element name="optional" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>If present, then prompt for leafs that are optional.
                      If not, skip these objects.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="value" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains a string representing the content
                      to use for the filled variable.
                      
                      If a string is entered, then the target value being
                      filled must be a leaf or leaf-list.
                      
                      If a variable is referenced, then it will
                      be used as the content, if the target value being
                      filled is a leaf or a leaf-list.
                      
                      If the target value is a complex object,
                      then the referenced variable must also be
                      a complex object of the same type. E.g.,
                      
                      The global variable 'foo' would be specified as:
                      
                          value=$$foo
                      
                      The local variable 'bar' would be specified as:
                      
                          value=$bar
                      
                      An error will be reported if the global or local
                      variable does not reference the same object type
                      as the target parameter.</xs:documentation>
                  </xs:annotation>
                  <xs:complexType>
                    <xs:complexContent>
                      <xs:extension base="xs:anyType"/>
                    </xs:complexContent>
                  </xs:complexType>
                </xs:element>
                <xs:element name="match-names" type="NameMatchMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="alt-names" type="AltNameMode"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:element name="nofill" minOccurs="0">
              <xs:annotation>
                <xs:documentation>If present, and the 'from-cli' option is used
                  for input, then filling of mandatory nodes
                  and key leafs will be skipped.  Instead, the target
                  object will be treated as a terminating select node
                  in the filter element.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="source">
              <xs:annotation>
                <xs:documentation>Particular configuration to retrieve.</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:choice>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:choice-name>config-source</ncx:choice-name>
                        <ncx:mandatory>true</ncx:mandatory>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:sequence>
                      <xs:annotation>
                        <xs:appinfo>
                          <ncx:case-name>candidate</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="candidate" minOccurs="0">
                        <xs:annotation>
                          <xs:documentation>Only available if 'candidate' capability supported.</xs:documentation>
                        </xs:annotation>
                      </xs:element>
                      <xs:any minOccurs="0" maxOccurs="unbounded"
                        namespace="##other" processContents="lax"/>
                    </xs:sequence>
                    <xs:sequence>
                      <xs:annotation>
                        <xs:appinfo>
                          <ncx:case-name>running</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="running" minOccurs="0"/>
                      <xs:any minOccurs="0" maxOccurs="unbounded"
                        namespace="##other" processContents="lax"/>
                    </xs:sequence>
                    <xs:sequence>
                      <xs:annotation>
                        <xs:appinfo>
                          <ncx:case-name>startup</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="startup" minOccurs="0">
                        <xs:annotation>
                          <xs:documentation>Only available if 'startup' capability supported.</xs:documentation>
                        </xs:annotation>
                      </xs:element>
                      <xs:any minOccurs="0" maxOccurs="unbounded"
                        namespace="##other" processContents="lax"/>
                    </xs:sequence>
                    <xs:sequence>
                      <xs:annotation>
                        <xs:appinfo>
                          <ncx:case-name>url</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="url" type="nc:ConfigURIType"
                        minOccurs="0">
                        <xs:annotation>
                          <xs:documentation>URL pointing to config data. Only available
                            if 'url' capability supported.</xs:documentation>
                        </xs:annotation>
                      </xs:element>
                      <xs:any minOccurs="0" maxOccurs="unbounded"
                        namespace="##other" processContents="lax"/>
                    </xs:sequence>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:choice>
                  <xs:any minOccurs="0" maxOccurs="unbounded"
                    namespace="##other" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="show_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="show" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Local show command for yangcli session info.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>show_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>showtype</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>cli</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="cli" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show the yangcli CLI parameters.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>module</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="module" type="yt:NcxIdentifier"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show full info for one module loaded
                      within the current session.</xs:documentation>
                  </xs:annotation>
                  <xs:simpleType>
                    <xs:union memberTypes="yt:NcxName&#32;yt:NcxQName"/>
                  </xs:simpleType>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>modules</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="modules" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show info for all modules loaded within the
                      current session.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>local</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="local" type="yt:NcxName"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show info for one local user variable.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>locals</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="locals" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show info for all local user variables.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>global</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="global" type="yt:NcxName"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show full info for one global user variable.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>globals</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="globals" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show info for all global user variables.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>objects</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="objects" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show config database objects loaded within the
                      current session.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>session</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="session" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show the current session info, including the initial
                      server capabilities for the session.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>system</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="system" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show the read-only system environment variables
                      and the read-write yangcli program variables.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>var</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="var" type="yt:NcxName" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show info for one local or global variable.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>vars</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="vars" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show truncated info for all program variables</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>version</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="version" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Show yangcli version info.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="start-timer_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="start-timer" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Start a timer to do simple performance measurements.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>start-timer_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>id</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="id" type="TimerId" default="0"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>The timer ID to use.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="restart-ok" type="xs:boolean"
              default="true" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Indicates whether the timer will be used if
                  it is already running.  If 'true', the timer
                  will be restarted if it is already running.
                  If 'false', an error will occur if the timer
                  is already running.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="stop-timer_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:element name="delta" type="xs:long" minOccurs="0">
            <xs:annotation>
              <xs:documentation>The elapsed time since the timer started.</xs:documentation>
              <xs:appinfo>
                <ncx:units>seconds</ncx:units>
              </xs:appinfo>
            </xs:annotation>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="stop-timer" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Stop a timer and output the delta value.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>stop-timer_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>id</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="id" type="TimerId" default="0"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>The timer ID to use.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="echo" type="xs:boolean" default="true"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Echo the elapsed time value to screen if in
                  interactive mode, as well as the log if the
                  log is a file instead of stdout.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="while_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="while" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Evaluate an XPath expression locally on the manager.
        and execute the block of commands that follow
        while the expression is true.  The block ends
        when a matching 'end' command is reached.
        </xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>while_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>expr</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="expr">
              <xs:annotation>
                <xs:documentation>XPath expression string to evaluate.
                  Use quotes if there are any whitespace or
                  special characters in the expression.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:simpleType>
                <xs:restriction base="yang:xpath1.0">
                  <xs:minLength value="1"/>
                </xs:restriction>
              </xs:simpleType>
            </xs:element>
            <xs:element name="docroot" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Use the contents of the specified variable or
                  external XML file as the conceptual document to
                  apply the expression specified in the 'expr' parameter.
                  
                  If this parameter is missing then a dummy document
                  will be used.  This is only allowed if the
                  expression only contains variable references
                  or numeric/string constants.</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:complexContent>
                  <xs:extension base="xs:anyType"/>
                </xs:complexContent>
              </xs:complexType>
            </xs:element>
            <xs:element name="maxloops" type="xs:unsignedInt"
              default="65535" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Set a maximum number of loops that can be
                  iterated for this while command.
                  The value zero means that no maximum will be
                  enforced.  Use this mode with caution.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="xget_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:element name="data" minOccurs="0">
            <xs:annotation>
              <xs:documentation>The data resulting from the retrieval operation.</xs:documentation>
            </xs:annotation>
            <xs:complexType>
              <xs:complexContent>
                <xs:extension base="xs:anyType"/>
              </xs:complexContent>
            </xs:complexType>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="xget" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Get some NETCONF running config or state data with the get
        operation, using an optional XPath filter.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>xget_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>select</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>from</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>varref</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="varref" type="xs:string"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Use the contents of the specified variable
                      as the content</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>select</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="select" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>The XPath expression to use in the retrieval
                      operation.  The string may only contain
                      single quotes, which are required for
                      string literals.  The entire string
                      will be inserted into a double-quoted
                      string, within the get-config PDU.
                      Character entities will be inserted as
                      needed to maintain well-formed XML.</xs:documentation>
                    <xs:appinfo>
                      <ncx:xpath/>
                    </xs:appinfo>
                  </xs:annotation>
                  <xs:simpleType>
                    <xs:restriction base="xs:string">
                      <xs:minLength value="1"/>
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>urltarget</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="urltarget" type="UrlPath"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>The URL path expression to use in the retrieval
                      operation.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:element name="timeout" type="yt:Timeout" default="30"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Timeout to use</xs:documentation>
                <xs:appinfo>
                  <ncx:units>seconds</ncx:units>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="match-names" type="NameMatchMode"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="alt-names" type="AltNameMode"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="xget-config_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:element name="data" minOccurs="0">
            <xs:annotation>
              <xs:documentation>The data resulting from the retrieval operation.</xs:documentation>
            </xs:annotation>
            <xs:complexType>
              <xs:complexContent>
                <xs:extension base="xs:anyType"/>
              </xs:complexContent>
            </xs:complexType>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="xget-config" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Get some NETCONF config data with the get-config
        operation, using an optional XPath filter.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>xget-config_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:annotation>
        <xs:appinfo>
          <ncx:default-parm>
            <ncx:parm>select</ncx:parm>
          </ncx:default-parm>
        </xs:appinfo>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>from</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>varref</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="varref" type="xs:string"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Use the contents of the specified variable
                      as the content</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>select</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="select" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>The XPath expression to use in the retrieval
                      operation.  The string may only contain
                      single quotes, which are required for
                      string literals.  The entire string
                      will be inserted into a double-quoted
                      string, within the get-config PDU.
                      Character entities will be inserted as
                      needed to maintain well-formed XML.</xs:documentation>
                    <xs:appinfo>
                      <ncx:xpath/>
                    </xs:appinfo>
                  </xs:annotation>
                  <xs:simpleType>
                    <xs:restriction base="xs:string">
                      <xs:minLength value="1"/>
                    </xs:restriction>
                  </xs:simpleType>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>urltarget</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="urltarget" type="UrlPath"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>The URL path expression to use in the retrieval
                      operation.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:element name="timeout" type="yt:Timeout" default="30"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Timeout to use</xs:documentation>
                <xs:appinfo>
                  <ncx:units>seconds</ncx:units>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="match-names" type="NameMatchMode"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="alt-names" type="AltNameMode"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Match mode to use for UrlPath name searches.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="source">
              <xs:annotation>
                <xs:documentation>Particular configuration to retrieve.</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:choice>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:choice-name>config-source</ncx:choice-name>
                        <ncx:mandatory>true</ncx:mandatory>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:sequence>
                      <xs:annotation>
                        <xs:appinfo>
                          <ncx:case-name>candidate</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="candidate" minOccurs="0">
                        <xs:annotation>
                          <xs:documentation>Only available if 'candidate' capability supported.</xs:documentation>
                        </xs:annotation>
                      </xs:element>
                      <xs:any minOccurs="0" maxOccurs="unbounded"
                        namespace="##other" processContents="lax"/>
                    </xs:sequence>
                    <xs:sequence>
                      <xs:annotation>
                        <xs:appinfo>
                          <ncx:case-name>running</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="running" minOccurs="0"/>
                      <xs:any minOccurs="0" maxOccurs="unbounded"
                        namespace="##other" processContents="lax"/>
                    </xs:sequence>
                    <xs:sequence>
                      <xs:annotation>
                        <xs:appinfo>
                          <ncx:case-name>startup</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="startup" minOccurs="0">
                        <xs:annotation>
                          <xs:documentation>Only available if 'startup' capability supported.</xs:documentation>
                        </xs:annotation>
                      </xs:element>
                      <xs:any minOccurs="0" maxOccurs="unbounded"
                        namespace="##other" processContents="lax"/>
                    </xs:sequence>
                    <xs:sequence>
                      <xs:annotation>
                        <xs:appinfo>
                          <ncx:case-name>url</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="url" type="nc:ConfigURIType"
                        minOccurs="0">
                        <xs:annotation>
                          <xs:documentation>URL pointing to config data. Only available
                            if 'url' capability supported.</xs:documentation>
                        </xs:annotation>
                      </xs:element>
                      <xs:any minOccurs="0" maxOccurs="unbounded"
                        namespace="##other" processContents="lax"/>
                    </xs:sequence>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:choice>
                  <xs:any minOccurs="0" maxOccurs="unbounded"
                    namespace="##other" processContents="lax"/>
                </xs:sequence>
              </xs:complexType>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="unset_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="unset" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Delete a specific yangcli command alias.
        
        * Delete one alias 'foo':
          yangcli&gt;  unset foo
        </xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>unset_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="name" type="yt:NcxName">
              <xs:annotation>
                <xs:documentation>Name of the yangcli command alias to delete.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="uservars_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="uservars" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Manage the yangcli user variables</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>uservars_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>uservars-action</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>clear</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="clear" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Delete all the yangcli user variables from memory.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>load</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="load" type="xs:string"
                  default="~/.yuma/yangcli_uservars.xml" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Load the yangcli user variables from the
                      specified XML file spec.  The default user variables
                      file will be loaded automatically at startup
                      if the '--autouservars' parameter is present.
                      The container 'vars' data structure represents
                      the format of the XML file expected.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>save</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="save" type="xs:string"
                  default="~/.yuma/yangcli_uservars.xml" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Save the yangcli user variables to the
                      specified filespec. The default user variables
                      file will be saved automatically at shutdown
                      if the '--autouservars' parameter is present.
                      The container 'vars' data structure represents
                      the format of the XML file that will be written.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:any minOccurs="0" maxOccurs="unbounded"
                  namespace="##other" processContents="lax"/>
              </xs:sequence>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:choice>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
  <xs:element name="vars">
    <xs:annotation>
      <xs:documentation>Represents all saved yangcli user variables</xs:documentation>
      <xs:appinfo>
        <ncx:config>true</ncx:config>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element name="var" minOccurs="0" maxOccurs="unbounded">
          <xs:annotation>
            <xs:documentation>Data structure to save one yangcli user variable</xs:documentation>
            <xs:appinfo>
              <ncx:ordered-by>system</ncx:ordered-by>
            </xs:appinfo>
          </xs:annotation>
          <xs:complexType>
            <xs:sequence>
              <xs:element name="name" type="yt:NcxName">
                <xs:annotation>
                  <xs:documentation>Name of the user variable</xs:documentation>
                </xs:annotation>
              </xs:element>
              <xs:element name="target" type="xs:string" minOccurs="0">
                <xs:annotation>
                  <xs:documentation>Target variable if variable represents a node
                    from a datastore.</xs:documentation>
                </xs:annotation>
              </xs:element>
              <xs:element name="vartype" type="YangcliVariableType"
                default="global" minOccurs="0">
                <xs:annotation>
                  <xs:documentation>User variable type; only 'global' variables can
                    be saved in the yangcli uservars file.</xs:documentation>
                </xs:annotation>
              </xs:element>
              <xs:element name="value" minOccurs="0">
                <xs:annotation>
                  <xs:documentation>Node value renamed to 'value' since YANG requires
                    each node to have a consistent name.</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                  <xs:complexContent>
                    <xs:extension base="xs:anyType"/>
                  </xs:complexContent>
                </xs:complexType>
              </xs:element>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:sequence>
          </xs:complexType>
          <xs:key name="varkey154">
            <xs:selector xpath="."/>
            <xs:field xpath="name"/>
          </xs:key>
        </xs:element>
        <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"
          processContents="lax"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

