<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"
  targetNamespace="urn:ietf:params:xml:ns:netconf:base:1.0"
  elementFormDefault="qualified" attributeFormDefault="unqualified"
  xml:lang="en" version="2011-05-30"
  xmlns:ncx="http://netconfcentral.org/ns/yuma-ncx"
  xmlns:nc="urn:ietf:params:xml:ns:netconf:base:1.0"
  xmlns:inet="urn:ietf:params:xml:ns:yang:ietf-inet-types"
  xmlns:yang="urn:ietf:params:xml:ns:yang:ietf-yang-types"
  xmlns:nacm1="http://netconfcentral.org/ns/yuma-nacm">
  <xs:annotation>
    <xs:documentation>Converted from YANG file 'yuma-netconf.yang' by yangdump version 2.2.1737
      
      Module: yuma-netconf
      Version: 2011-05-30
      Contact: Translated by Andy Bierman.
      Send comments to &lt;andy@netconfcentral.org&gt;.</xs:documentation>
    <xs:documentation>NETCONF Protocol
       * Data Types
       * Abstract object for PDU components
       * RPCs
      Translated from RFC 4741.</xs:documentation>
    <xs:appinfo>
      <ncx:source>/usr/share/yuma/modules/netconfcentral/yuma-netconf.yang</ncx:source>
      <ncx:contact>Translated by Andy Bierman.
        Send comments to &lt;andy@netconfcentral.org&gt;.</ncx:contact>
    </xs:appinfo>
    <xs:appinfo>
      <ncx:revision>
        <ncx:version>2011-05-30</ncx:version>
        <ncx:description>Update for NETCONF base:1.1 version</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2010-05-24</ncx:version>
        <ncx:description>Align rpc statements with ietf-netconf.yang</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2010-05-06</ncx:version>
        <ncx:description>Remove nacm:secure on delete-config;
          Fix bugs in parameters that did not match ietf-netconf.yang.</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2009-04-10</ncx:version>
        <ncx:description>Remove rpc-type extension usage.</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2009-02-24</ncx:version>
        <ncx:description>Change yang:uri to inet:uri (import moved).</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2008-08-30</ncx:version>
        <ncx:description>Add some NCX extensions to automate some server processing.</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2008-04-26</ncx:version>
        <ncx:description>Change get-config and get output from 'config' to 'data'.</ncx:description>
      </ncx:revision>
      <ncx:revision>
        <ncx:version>2008-04-16</ncx:version>
        <ncx:description>Initial conversion from netconf.ncx version 0.6.</ncx:description>
      </ncx:revision>
    </xs:appinfo>
  </xs:annotation>
  <xs:simpleType name="Language">
    <xs:annotation>
      <xs:documentation>XML language type for LangString</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:pattern value="[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="session-id-type">
    <xs:annotation>
      <xs:documentation>NETCONF Session Id</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:unsignedInt">
      <xs:minInclusive value="1"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="session-id-or-zero-type">
    <xs:annotation>
      <xs:documentation>NETCONF Session Id or Zero to indicate none</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:unsignedInt"/>
  </xs:simpleType>
  <xs:simpleType name="ConfigURIType">
    <xs:restriction base="inet:uri"/>
  </xs:simpleType>
  <xs:simpleType name="LangString">
    <xs:annotation>
      <xs:documentation>XML string with a language attribute.</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="MessageId">
    <xs:annotation>
      <xs:documentation>NETCONF message-id attribute</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:minLength value="1"/>
      <xs:maxLength value="4095"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="ErrorType">
    <xs:annotation>
      <xs:documentation>NETCONF Error Type</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:enumeration value="transport">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>0</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="rpc">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>1</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="protocol">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>2</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="application">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>3</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="ErrorTag">
    <xs:annotation>
      <xs:documentation>NETCONF Error Tag</xs:documentation>
      <xs:appinfo>
        <ncx:reference>
          <ncx:text>RFC 6241, Appendix A.</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc6241.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:enumeration value="in-use">
        <xs:annotation>
          <xs:documentation>The request requires a resource that
            already is in use.</xs:documentation>
          <xs:appinfo>
            <ncx:value>0</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="invalid-value">
        <xs:annotation>
          <xs:documentation>The request specifies an unacceptable value for one
            or more parameters.</xs:documentation>
          <xs:appinfo>
            <ncx:value>1</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="too-big">
        <xs:annotation>
          <xs:documentation>The request or response (that would be generated) is
            too large for the implementation to handle.</xs:documentation>
          <xs:appinfo>
            <ncx:value>2</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="missing-attribute">
        <xs:annotation>
          <xs:documentation>An expected attribute is missing.</xs:documentation>
          <xs:appinfo>
            <ncx:value>3</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="bad-attribute">
        <xs:annotation>
          <xs:documentation>An attribute value is not correct; e.g., wrong type,
            out of range, pattern mismatch.</xs:documentation>
          <xs:appinfo>
            <ncx:value>4</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="unknown-attribute">
        <xs:annotation>
          <xs:documentation>An unexpected attribute is present.</xs:documentation>
          <xs:appinfo>
            <ncx:value>5</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="missing-element">
        <xs:annotation>
          <xs:documentation>An expected element is missing.</xs:documentation>
          <xs:appinfo>
            <ncx:value>6</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="bad-element">
        <xs:annotation>
          <xs:documentation>An element value is not correct; e.g., wrong type,
            out of range, pattern mismatch.</xs:documentation>
          <xs:appinfo>
            <ncx:value>7</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="unknown-element">
        <xs:annotation>
          <xs:documentation>An unexpected element is present.</xs:documentation>
          <xs:appinfo>
            <ncx:value>8</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="unknown-namespace">
        <xs:annotation>
          <xs:documentation>An unexpected namespace is present.</xs:documentation>
          <xs:appinfo>
            <ncx:value>9</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="access-denied">
        <xs:annotation>
          <xs:documentation>Access to the requested protocol operation, or
            data model is denied because authorization failed.</xs:documentation>
          <xs:appinfo>
            <ncx:value>10</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="lock-denied">
        <xs:annotation>
          <xs:documentation>Access to the requested lock is denied because the
            lock is currently held by another entity.</xs:documentation>
          <xs:appinfo>
            <ncx:value>11</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="resource-denied">
        <xs:annotation>
          <xs:documentation>Request could not be completed because of
            insufficient resources.</xs:documentation>
          <xs:appinfo>
            <ncx:value>12</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="rollback-failed">
        <xs:annotation>
          <xs:documentation>Request to rollback some configuration change (via
            rollback-on-error or discard-changes operations) was
            not completed for some reason.</xs:documentation>
          <xs:appinfo>
            <ncx:value>13</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="data-exists">
        <xs:annotation>
          <xs:documentation>Request could not be completed because the relevant
            data model content already exists. For example,
            a 'create' operation was attempted on data that
            already exists.</xs:documentation>
          <xs:appinfo>
            <ncx:value>14</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="data-missing">
        <xs:annotation>
          <xs:documentation>Request could not be completed because the relevant
            data model content does not exist.  For example,
            a 'delete' operation was attempted on
            data that does not exist.</xs:documentation>
          <xs:appinfo>
            <ncx:value>15</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="operation-not-supported">
        <xs:annotation>
          <xs:documentation>Request could not be completed because the requested
            operation is not supported by this implementation.</xs:documentation>
          <xs:appinfo>
            <ncx:value>16</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="operation-failed">
        <xs:annotation>
          <xs:documentation>Request could not be completed because the requested
            operation failed for some reason not covered by
            any other error condition.</xs:documentation>
          <xs:appinfo>
            <ncx:value>17</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="partial-operation">
        <xs:annotation>
          <xs:documentation>This error-tag is obsolete, and SHOULD NOT be sent
            by servers conforming to this document.</xs:documentation>
          <xs:appinfo>
            <ncx:value>18</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="malformed-message">
        <xs:annotation>
          <xs:documentation>A message could not be handled because it failed to
            be parsed correctly. For example, the message is not
            well-formed XML or it uses an invalid character set.</xs:documentation>
          <xs:appinfo>
            <ncx:value>19</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="ErrorSeverity">
    <xs:annotation>
      <xs:documentation>NETCONF Error Severity</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:enumeration value="error">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>0</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="warning">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>1</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="TestOptionType">
    <xs:annotation>
      <xs:documentation>NETCONF 'test-option' Element Content.</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:enumeration value="test-then-set">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>0</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="set">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>1</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="test-only">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>2</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="ErrorOptionType">
    <xs:annotation>
      <xs:documentation>NETCONF 'error-option' Element Content</xs:documentation>
      <xs:appinfo>
        <ncx:default>stop-on-error</ncx:default>
      </xs:appinfo>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:enumeration value="stop-on-error">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>0</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="continue-on-error">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>1</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="rollback-on-error">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>2</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="FilterType">
    <xs:annotation>
      <xs:documentation>NETCONF 'filter' Attribute Content</xs:documentation>
      <xs:appinfo>
        <ncx:default>subtree</ncx:default>
      </xs:appinfo>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:enumeration value="subtree">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>0</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="xpath">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>1</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="SelectString">
    <xs:annotation>
      <xs:documentation>XPath string used in the select attribute.</xs:documentation>
    </xs:annotation>
    <xs:restriction base="xs:string"/>
  </xs:simpleType>
  <xs:simpleType name="EditOperationType">
    <xs:annotation>
      <xs:documentation>NETCONF 'operation' Attribute Content</xs:documentation>
      <xs:appinfo>
        <ncx:default>merge</ncx:default>
      </xs:appinfo>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:enumeration value="merge">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>0</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="replace">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>1</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="create">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>2</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="delete">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>3</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="remove">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>4</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="DefaultOperationType">
    <xs:annotation>
      <xs:documentation>NETCONF 'default-operation' Element Content</xs:documentation>
      <xs:appinfo>
        <ncx:default>merge</ncx:default>
      </xs:appinfo>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:enumeration value="merge">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>0</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="replace">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>1</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="none">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>2</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="ConfirmTimeoutType">
    <xs:annotation>
      <xs:documentation>NETCONF 'confirm-timeout' Element Content</xs:documentation>
      <xs:appinfo>
        <ncx:units>seconds</ncx:units>
        <ncx:default>600</ncx:default>
      </xs:appinfo>
    </xs:annotation>
    <xs:restriction base="xs:unsignedInt">
      <xs:minInclusive value="1"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:group name="NcCapabilities">
    <xs:annotation>
      <xs:documentation>Generic Capabilities List.</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="capabilities">
        <xs:annotation>
          <xs:appinfo>
            <ncx:config>false</ncx:config>
          </xs:appinfo>
        </xs:annotation>
        <xs:complexType>
          <xs:sequence>
            <xs:element name="capability" type="inet:uri" minOccurs="0"
              maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>One Generic Capability URI.</xs:documentation>
                <xs:appinfo>
                  <ncx:ordered-by>system</ncx:ordered-by>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:any minOccurs="0" maxOccurs="unbounded"
              namespace="##other" processContents="lax"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
  </xs:group>
  <xs:group name="ErrorInfoContent">
    <xs:annotation>
      <xs:documentation>NETCONF standard 'error-info' Element Content;</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="bad-attribute" type="xs:string" minOccurs="0"
        maxOccurs="unbounded">
        <xs:annotation>
          <xs:documentation>Name of the missing or invalid XSD attribute.
            Used with missing-attribute, bad-attribute, and
            unknown-attribute error-tag values.</xs:documentation>
          <xs:appinfo>
            <ncx:config>false</ncx:config>
            <ncx:ordered-by>system</ncx:ordered-by>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="bad-element" type="xs:string" minOccurs="0"
        maxOccurs="unbounded">
        <xs:annotation>
          <xs:documentation>Name of the element that contains (or should contain)
            an invalid XSD attribute when used with missing-attribute,
            bad-attribute, unknown-attribute, error-tag values.
            Name of an invalid or missing element when used with
            then missing-element, bad-element, unknown-element,
            and unknown-namespace error-tag values.</xs:documentation>
          <xs:appinfo>
            <ncx:config>false</ncx:config>
            <ncx:ordered-by>system</ncx:ordered-by>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="ok-element" type="xs:string" minOccurs="0"
        maxOccurs="unbounded">
        <xs:annotation>
          <xs:documentation>Identifies an element in the data model
            for which the requested operation has been completed
            for that node and all its child nodes.  This element
            can appear zero or more times in the 'error-info'
            container.  Used with the partial-operation error-tag
            value.</xs:documentation>
          <xs:appinfo>
            <ncx:config>false</ncx:config>
            <ncx:ordered-by>system</ncx:ordered-by>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="err-element" type="xs:string" minOccurs="0"
        maxOccurs="unbounded">
        <xs:annotation>
          <xs:documentation>Identifies an element in the data model
            for which the requested operation has failed for that
            node and all its child nodes.  This element
            can appear zero or more times in the 'error-info'
            container.   Used with the partial-operation error-tag
            value.</xs:documentation>
          <xs:appinfo>
            <ncx:config>false</ncx:config>
            <ncx:ordered-by>system</ncx:ordered-by>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="noop-element" type="xs:string" minOccurs="0"
        maxOccurs="unbounded">
        <xs:annotation>
          <xs:documentation>Identifies an element in the data model
            for which the requested operation was not attempted for
            that node and all its child nodes.  This element
            can appear zero or more times in the &lt;error-info&gt;
            container.   Used with the partial-operation error-tag
            value.</xs:documentation>
          <xs:appinfo>
            <ncx:config>false</ncx:config>
            <ncx:ordered-by>system</ncx:ordered-by>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="session-id" type="session-id-or-zero-type"
        minOccurs="0">
        <xs:annotation>
          <xs:documentation>Session ID of session holding the
            requested lock, or zero to indicate a non-NETCONF
            entity holds the lock.</xs:documentation>
          <xs:appinfo>
            <ncx:config>false</ncx:config>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
    </xs:sequence>
  </xs:group>
  <xs:group name="RpcErrorType">
    <xs:annotation>
      <xs:documentation>NETCONF 'rpc-error' Element Content</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="error-type" type="ErrorType">
        <xs:annotation>
          <xs:documentation>Defines the conceptual layer that the error occurred.</xs:documentation>
          <xs:appinfo>
            <ncx:mandatory>true</ncx:mandatory>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="error-tag" type="ErrorTag">
        <xs:annotation>
          <xs:documentation>Contains a string identifying the error condition.</xs:documentation>
          <xs:appinfo>
            <ncx:mandatory>true</ncx:mandatory>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="error-severity" type="ErrorSeverity">
        <xs:annotation>
          <xs:documentation>Contains a string identifying the error severity, as
            determined by the device.</xs:documentation>
          <xs:appinfo>
            <ncx:mandatory>true</ncx:mandatory>
          </xs:appinfo>
        </xs:annotation>
      </xs:element>
      <xs:element name="error-app-tag" type="xs:string" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Contains a string identifying the data-model-specific
            or implementation-specific error condition, if one exists.
            This element will not be present if no appropriate
            application error tag can be associated with a particular
            error condition.</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name="error-path" type="yang:xpath1.0" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Contains the absolute XPath [2] expression identifying
            the element path to the node that is associated with the error
            being reported in a particular rpc-error element.  This element
            will not be present if no appropriate payload element can be
            associated with a particular error condition, or if the
            'bad-element' QString returned in the 'error-info' container is
            sufficient to identify the node associated with the error.  When
            the XPath expression is interpreted, the set of namespace
            declarations are those in scope on the rpc-error element,
            including the default namespace.</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name="error-message" type="LangString" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Contains a string suitable for human display that
            describes the error condition.  This element will not be present
            if no appropriate message is provided for a particular error
            condition.  This element SHOULD include an xml:lang attribute.</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name="error-info" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Contains protocol- or data-model-specific error content.
            This element will not be present if no such error content is
            provided for a particular error condition.  The list in
            RFC 4741, Appendix A, defines any mandatory error-info content
            for each error.  After any protocol-mandated content, a
            data model definition may mandate that certain application-layer
            error information be included in the error-info container.
            An implementation may include additional elements to
            provide extended and/or implementation-specific debugging
            information.</xs:documentation>
        </xs:annotation>
        <xs:complexType>
          <xs:complexContent>
            <xs:extension base="xs:anyType"/>
          </xs:complexContent>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
  </xs:group>
  <xs:group name="RpcDataReplyType">
    <xs:annotation>
      <xs:documentation>NETCONF 'rpc-reply' Error and/or Data Content</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="rpc-error" minOccurs="0" maxOccurs="unbounded">
        <xs:annotation>
          <xs:appinfo>
            <ncx:config>false</ncx:config>
            <ncx:ordered-by>system</ncx:ordered-by>
          </xs:appinfo>
        </xs:annotation>
        <xs:complexType>
          <xs:sequence>
            <xs:element name="error-type" type="ErrorType">
              <xs:annotation>
                <xs:documentation>Defines the conceptual layer that the error occurred.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="error-tag" type="ErrorTag">
              <xs:annotation>
                <xs:documentation>Contains a string identifying the error condition.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="error-severity" type="ErrorSeverity">
              <xs:annotation>
                <xs:documentation>Contains a string identifying the error severity, as
                  determined by the device.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="error-app-tag" type="xs:string"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Contains a string identifying the data-model-specific
                  or implementation-specific error condition, if one exists.
                  This element will not be present if no appropriate
                  application error tag can be associated with a particular
                  error condition.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="error-path" type="yang:xpath1.0"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Contains the absolute XPath [2] expression identifying
                  the element path to the node that is associated with the error
                  being reported in a particular rpc-error element.  This element
                  will not be present if no appropriate payload element can be
                  associated with a particular error condition, or if the
                  'bad-element' QString returned in the 'error-info' container is
                  sufficient to identify the node associated with the error.  When
                  the XPath expression is interpreted, the set of namespace
                  declarations are those in scope on the rpc-error element,
                  including the default namespace.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="error-message" type="LangString"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Contains a string suitable for human display that
                  describes the error condition.  This element will not be present
                  if no appropriate message is provided for a particular error
                  condition.  This element SHOULD include an xml:lang attribute.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="error-info" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Contains protocol- or data-model-specific error content.
                  This element will not be present if no such error content is
                  provided for a particular error condition.  The list in
                  RFC 4741, Appendix A, defines any mandatory error-info content
                  for each error.  After any protocol-mandated content, a
                  data model definition may mandate that certain application-layer
                  error information be included in the error-info container.
                  An implementation may include additional elements to
                  provide extended and/or implementation-specific debugging
                  information.</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:element>
    </xs:sequence>
  </xs:group>
  <xs:group name="RpcOkReplyType">
    <xs:annotation>
      <xs:documentation>NETCONF 'rpc-reply' OK Content.</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:choice>
        <xs:annotation>
          <xs:appinfo>
            <ncx:choice-name>ok-or-error</ncx:choice-name>
          </xs:appinfo>
        </xs:annotation>
        <xs:sequence>
          <xs:annotation>
            <xs:appinfo>
              <ncx:case-name>ok</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:element name="ok" minOccurs="0">
            <xs:annotation>
              <xs:documentation>Sent in 'rpc-reply' messages if no errors or
                warnings occurred during the processing of an 'rpc' request.</xs:documentation>
              <xs:appinfo>
                <ncx:config>false</ncx:config>
              </xs:appinfo>
            </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>rpc-error</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:element name="rpc-error" minOccurs="0"
            maxOccurs="unbounded">
            <xs:annotation>
              <xs:appinfo>
                <ncx:config>false</ncx:config>
                <ncx:ordered-by>system</ncx:ordered-by>
              </xs:appinfo>
            </xs:annotation>
            <xs:complexType>
              <xs:sequence>
                <xs:element name="error-type" type="ErrorType">
                  <xs:annotation>
                    <xs:documentation>Defines the conceptual layer that the error occurred.</xs:documentation>
                    <xs:appinfo>
                      <ncx:mandatory>true</ncx:mandatory>
                    </xs:appinfo>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-tag" type="ErrorTag">
                  <xs:annotation>
                    <xs:documentation>Contains a string identifying the error condition.</xs:documentation>
                    <xs:appinfo>
                      <ncx:mandatory>true</ncx:mandatory>
                    </xs:appinfo>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-severity" type="ErrorSeverity">
                  <xs:annotation>
                    <xs:documentation>Contains a string identifying the error severity, as
                      determined by the device.</xs:documentation>
                    <xs:appinfo>
                      <ncx:mandatory>true</ncx:mandatory>
                    </xs:appinfo>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-app-tag" type="xs:string"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains a string identifying the data-model-specific
                      or implementation-specific error condition, if one exists.
                      This element will not be present if no appropriate
                      application error tag can be associated with a particular
                      error condition.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-path" type="yang:xpath1.0"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains the absolute XPath [2] expression identifying
                      the element path to the node that is associated with the error
                      being reported in a particular rpc-error element.  This element
                      will not be present if no appropriate payload element can be
                      associated with a particular error condition, or if the
                      'bad-element' QString returned in the 'error-info' container is
                      sufficient to identify the node associated with the error.  When
                      the XPath expression is interpreted, the set of namespace
                      declarations are those in scope on the rpc-error element,
                      including the default namespace.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-message" type="LangString"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains a string suitable for human display that
                      describes the error condition.  This element will not be present
                      if no appropriate message is provided for a particular error
                      condition.  This element SHOULD include an xml:lang attribute.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-info" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains protocol- or data-model-specific error content.
                      This element will not be present if no such error content is
                      provided for a particular error condition.  The list in
                      RFC 4741, Appendix A, defines any mandatory error-info content
                      for each error.  After any protocol-mandated content, a
                      data model definition may mandate that certain application-layer
                      error information be included in the error-info container.
                      An implementation may include additional elements to
                      provide extended and/or implementation-specific debugging
                      information.</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: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="RpcReplyType">
    <xs:annotation>
      <xs:documentation>Generic NETCONF 'rpc-reply' content. </xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:choice>
        <xs:annotation>
          <xs:appinfo>
            <ncx:choice-name>ok-or-data-error</ncx:choice-name>
          </xs:appinfo>
        </xs:annotation>
        <xs:sequence>
          <xs:annotation>
            <xs:appinfo>
              <ncx:case-name>ok</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:element name="ok" minOccurs="0">
            <xs:annotation>
              <xs:documentation>Sent in 'rpc-reply' messages if no errors or
                warnings occurred during the processing of an 'rpc' request.</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>data-error</ncx:case-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:element name="rpc-error" minOccurs="0"
            maxOccurs="unbounded">
            <xs:annotation>
              <xs:appinfo>
                <ncx:config>false</ncx:config>
                <ncx:ordered-by>system</ncx:ordered-by>
              </xs:appinfo>
            </xs:annotation>
            <xs:complexType>
              <xs:sequence>
                <xs:element name="error-type" type="ErrorType">
                  <xs:annotation>
                    <xs:documentation>Defines the conceptual layer that the error occurred.</xs:documentation>
                    <xs:appinfo>
                      <ncx:mandatory>true</ncx:mandatory>
                    </xs:appinfo>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-tag" type="ErrorTag">
                  <xs:annotation>
                    <xs:documentation>Contains a string identifying the error condition.</xs:documentation>
                    <xs:appinfo>
                      <ncx:mandatory>true</ncx:mandatory>
                    </xs:appinfo>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-severity" type="ErrorSeverity">
                  <xs:annotation>
                    <xs:documentation>Contains a string identifying the error severity, as
                      determined by the device.</xs:documentation>
                    <xs:appinfo>
                      <ncx:mandatory>true</ncx:mandatory>
                    </xs:appinfo>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-app-tag" type="xs:string"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains a string identifying the data-model-specific
                      or implementation-specific error condition, if one exists.
                      This element will not be present if no appropriate
                      application error tag can be associated with a particular
                      error condition.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-path" type="yang:xpath1.0"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains the absolute XPath [2] expression identifying
                      the element path to the node that is associated with the error
                      being reported in a particular rpc-error element.  This element
                      will not be present if no appropriate payload element can be
                      associated with a particular error condition, or if the
                      'bad-element' QString returned in the 'error-info' container is
                      sufficient to identify the node associated with the error.  When
                      the XPath expression is interpreted, the set of namespace
                      declarations are those in scope on the rpc-error element,
                      including the default namespace.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-message" type="LangString"
                  minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains a string suitable for human display that
                      describes the error condition.  This element will not be present
                      if no appropriate message is provided for a particular error
                      condition.  This element SHOULD include an xml:lang attribute.</xs:documentation>
                  </xs:annotation>
                </xs:element>
                <xs:element name="error-info" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Contains protocol- or data-model-specific error content.
                      This element will not be present if no such error content is
                      provided for a particular error condition.  The list in
                      RFC 4741, Appendix A, defines any mandatory error-info content
                      for each error.  After any protocol-mandated content, a
                      data model definition may mandate that certain application-layer
                      error information be included in the error-info container.
                      An implementation may include additional elements to
                      provide extended and/or implementation-specific debugging
                      information.</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: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:element name="rpc">
    <xs:annotation>
      <xs:documentation>Remote Procedure Call request message</xs:documentation>
      <xs:appinfo>
        <ncx:config>true</ncx:config>
        <ncx:reference>
          <ncx:text>RFC 4741, section 4.1</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
        <ncx:metadata>
          <ncx:syntax-string>MessageId message-id</ncx:syntax-string>
        </ncx:metadata>
        <ncx:abstract/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"
          processContents="lax"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="rpc-reply">
    <xs:annotation>
      <xs:documentation>Remote Procedure Call response message</xs:documentation>
      <xs:appinfo>
        <ncx:config>true</ncx:config>
        <ncx:reference>
          <ncx:text>RFC 4741, section 4.2</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
        <ncx:metadata>
          <ncx:syntax-string>MessageId message-id</ncx:syntax-string>
        </ncx:metadata>
        <ncx:abstract/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:choice>
          <xs:annotation>
            <xs:appinfo>
              <ncx:choice-name>ok-or-data-error</ncx:choice-name>
            </xs:appinfo>
          </xs:annotation>
          <xs:sequence>
            <xs:annotation>
              <xs:appinfo>
                <ncx:case-name>ok</ncx:case-name>
              </xs:appinfo>
            </xs:annotation>
            <xs:element name="ok" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Sent in 'rpc-reply' messages if no errors or
                  warnings occurred during the processing of an 'rpc' request.</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>data-error</ncx:case-name>
              </xs:appinfo>
            </xs:annotation>
            <xs:element name="rpc-error" minOccurs="0"
              maxOccurs="unbounded">
              <xs:annotation>
                <xs:appinfo>
                  <ncx:config>false</ncx:config>
                  <ncx:ordered-by>system</ncx:ordered-by>
                </xs:appinfo>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:element name="error-type" type="ErrorType">
                    <xs:annotation>
                      <xs:documentation>Defines the conceptual layer that the error occurred.</xs:documentation>
                      <xs:appinfo>
                        <ncx:mandatory>true</ncx:mandatory>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:element>
                  <xs:element name="error-tag" type="ErrorTag">
                    <xs:annotation>
                      <xs:documentation>Contains a string identifying the error condition.</xs:documentation>
                      <xs:appinfo>
                        <ncx:mandatory>true</ncx:mandatory>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:element>
                  <xs:element name="error-severity"
                    type="ErrorSeverity">
                    <xs:annotation>
                      <xs:documentation>Contains a string identifying the error severity, as
                        determined by the device.</xs:documentation>
                      <xs:appinfo>
                        <ncx:mandatory>true</ncx:mandatory>
                      </xs:appinfo>
                    </xs:annotation>
                  </xs:element>
                  <xs:element name="error-app-tag" type="xs:string"
                    minOccurs="0">
                    <xs:annotation>
                      <xs:documentation>Contains a string identifying the data-model-specific
                        or implementation-specific error condition, if one exists.
                        This element will not be present if no appropriate
                        application error tag can be associated with a particular
                        error condition.</xs:documentation>
                    </xs:annotation>
                  </xs:element>
                  <xs:element name="error-path" type="yang:xpath1.0"
                    minOccurs="0">
                    <xs:annotation>
                      <xs:documentation>Contains the absolute XPath [2] expression identifying
                        the element path to the node that is associated with the error
                        being reported in a particular rpc-error element.  This element
                        will not be present if no appropriate payload element can be
                        associated with a particular error condition, or if the
                        'bad-element' QString returned in the 'error-info' container is
                        sufficient to identify the node associated with the error.  When
                        the XPath expression is interpreted, the set of namespace
                        declarations are those in scope on the rpc-error element,
                        including the default namespace.</xs:documentation>
                    </xs:annotation>
                  </xs:element>
                  <xs:element name="error-message" type="LangString"
                    minOccurs="0">
                    <xs:annotation>
                      <xs:documentation>Contains a string suitable for human display that
                        describes the error condition.  This element will not be present
                        if no appropriate message is provided for a particular error
                        condition.  This element SHOULD include an xml:lang attribute.</xs:documentation>
                    </xs:annotation>
                  </xs:element>
                  <xs:element name="error-info" minOccurs="0">
                    <xs:annotation>
                      <xs:documentation>Contains protocol- or data-model-specific error content.
                        This element will not be present if no such error content is
                        provided for a particular error condition.  The list in
                        RFC 4741, Appendix A, defines any mandatory error-info content
                        for each error.  After any protocol-mandated content, a
                        data model definition may mandate that certain application-layer
                        error information be included in the error-info container.
                        An implementation may include additional elements to
                        provide extended and/or implementation-specific debugging
                        information.</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: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:complexType name="get-config_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:element name="data">
            <xs:annotation>
              <xs:documentation>Copy of the source database subset which matched
                the filter criteria (if any).</xs:documentation>
              <xs:appinfo>
                <ncx:config>true</ncx:config>
                <ncx:presence>An empty data container indicates that the
                  request did not produce any results.</ncx:presence>
                <ncx:root/>
              </xs:appinfo>
            </xs:annotation>
            <xs:complexType>
              <xs:sequence>
                <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 name="get-config" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Retrieve all or part of a specified configuration.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>get-config_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 7.2</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <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: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>This is optional-to-implement on the server because
                            not all servers will support filtering for this
                            database.</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:element name="filter" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Subtree or Xpath filter to use.</xs:documentation>
                <xs:appinfo>
                  <nc:get-filter-element-attributes/>
                  <ncx:metadata>
                    <ncx:syntax-string>FilterType type</ncx:syntax-string>
                  </ncx:metadata>
                  <ncx:metadata>
                    <ncx:syntax-string>SelectString select</ncx:syntax-string>
                  </ncx:metadata>
                </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>
  <xs:complexType name="edit-config_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="edit-config" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>The 'edit-config' operation loads all or part of a specified
        configuration to the specified target configuration.  This
        operation allows the new configuration to be expressed in several
        ways, such as using a local file, a remote file, or inline.  If
        the target configuration does not exist, it will be created.  If a
        NETCONF peer supports the :url capability (Section 8.8), the &lt;url&gt;
        element can appear instead of the &lt;config&gt; parameter and should
        identify a local configuration file.
        
        The device analyzes the source and target configurations and
        performs the requested changes.  The target configuration is not
        necessarily replaced, as with the &lt;copy-config&gt; message.  Instead,
        the target configuration is changed in accordance with the
        source's data and requested operations.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>edit-config_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 7.2</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="target">
              <xs:annotation>
                <xs:documentation>Particular configuration to edit.</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:choice>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:choice-name>config-target</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: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: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:element name="default-operation"
              type="DefaultOperationType" default="merge" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Default operation to apply if not explicitly set.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="test-option" type="TestOptionType"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>Test option if validate capability supported.
                  The 'validate' capability must be present to set
                  this object to 'test-then-set'.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="error-option" type="ErrorOptionType"
              default="stop-on-error" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Error recovery option.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:choice>
              <xs:annotation>
                <xs:appinfo>
                  <ncx:choice-name>edit-content</ncx:choice-name>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
              <xs:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>config</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="config">
                  <xs:annotation>
                    <xs:documentation>Inline Config content: 'config' element.</xs:documentation>
                    <xs:appinfo>
                      <ncx:config>true</ncx:config>
                      <ncx:root/>
                    </xs:appinfo>
                  </xs:annotation>
                  <xs:complexType>
                    <xs:sequence>
                      <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:sequence>
                <xs:annotation>
                  <xs:appinfo>
                    <ncx:case-name>url</ncx:case-name>
                  </xs:appinfo>
                </xs:annotation>
                <xs:element name="url" type="inet:uri" minOccurs="0">
                  <xs:annotation>
                    <xs:documentation>Pointer to Config content: 'url' element.</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="copy-config_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="copy-config" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Create or replace an entire configuration datastore with the
        contents of another complete configuration datastore.  If the
        target datastore exists, it is overwritten.  Otherwise, a new one
        is created, if allowed.
        
        If a NETCONF peer supports the :url capability (Section 8.8), the
        'url' element can appear as the &lt;source&gt; or &lt;target&gt; parameter.
        
        Even if it advertises the :writable-running capability, a device
        may choose not to support the &lt;running/&gt; configuration datastore
        as the &lt;target&gt; parameter of a &lt;copy-config&gt; operation.  A device
        may choose not to support remote-to-remote copy operations, where
        both the &lt;source&gt; and &lt;target&gt; parameters use the &lt;url&gt; element.
        
        If the source and target parameters identify the same URL or
        configuration datastore, an error MUST be returned with an error-
        tag containing invalid-value.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>copy-config_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 7.3</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="target">
              <xs:annotation>
                <xs:documentation>Particular configuration to copy to.</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:choice>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:choice-name>config-target</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: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:annotation>
                          <xs:documentation>This is optional-to-implement on the server.</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>startup</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="startup" minOccurs="0"/>
                      <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="inet:uri"
                        minOccurs="0"/>
                      <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:element name="source">
              <xs:annotation>
                <xs:documentation>Particular configuration to copy from.</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: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: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="inet:uri"
                        minOccurs="0"/>
                      <xs:any minOccurs="0" maxOccurs="unbounded"
                        namespace="##other" processContents="lax"/>
                    </xs:sequence>
                    <xs:sequence>
                      <xs:annotation>
                        <xs:appinfo>
                          <ncx:case-name>config</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="config">
                        <xs:annotation>
                          <xs:documentation>Inline Config content: 'config' element.
                            Represents an entire 'stand-alone'
                            configuration database, not a subset of
                            the running database.</xs:documentation>
                          <xs:appinfo>
                            <ncx:config>true</ncx:config>
                            <ncx:root/>
                          </xs:appinfo>
                        </xs:annotation>
                        <xs:complexType>
                          <xs:sequence>
                            <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: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="delete-config_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-config" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Delete a configuration datastore.  The 'running' configuration
        datastore cannot be deleted.
        
        If a NETCONF peer supports the :url capability (Section 8.8), the
        'url' element can appear as the &lt;target&gt; parameter.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>delete-config_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 7.4</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="target">
              <xs:annotation>
                <xs:documentation>Particular configuration to delete.</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:choice>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:choice-name>config-target</ncx:choice-name>
                        <ncx:mandatory>true</ncx:mandatory>
                      </xs:appinfo>
                    </xs:annotation>
                    <xs:sequence>
                      <xs:annotation>
                        <xs:appinfo>
                          <ncx:case-name>startup</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="startup" minOccurs="0"/>
                      <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="inet:uri"
                        minOccurs="0"/>
                      <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="lock_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="lock" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>The lock operation allows the client to lock the configuration
        system of a device.  Such locks are intended to be short-lived and
        allow a client to make a change without fear of interaction with
        other NETCONF clients, non-NETCONF clients (e.g., SNMP and command
        line interface (CLI) scripts), and human users. ...</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>lock_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 7.5</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="target">
              <xs:annotation>
                <xs:documentation>Particular configuration to lock</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:choice>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:choice-name>config-target</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: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: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="unlock_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="unlock" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>The unlock operation is used to release a configuration lock,
        previously obtained with the 'lock' operation.
        
        An unlock operation will not succeed if any of the following
        conditions are true:
        
        *  the specified lock is not currently active
        
        *  the session issuing the &lt;unlock&gt; operation is not the same
           session that obtained the lock
        
        The server MUST respond with either an &lt;ok&gt; element or an
        'rpc-error'.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>unlock_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 7.6</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="target">
              <xs:annotation>
                <xs:documentation>Particular configuration to unlock.</xs:documentation>
              </xs:annotation>
              <xs:complexType>
                <xs:sequence>
                  <xs:choice>
                    <xs:annotation>
                      <xs:appinfo>
                        <ncx:choice-name>config-target</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: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: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="get_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:element name="data">
            <xs:annotation>
              <xs:documentation>Copy of the 'running' database subset and/or state
                data which matched the filter criteria (if any).</xs:documentation>
              <xs:appinfo>
                <ncx:config>true</ncx:config>
                <ncx:presence>An empty data container indicates that the filter
                  request did not match any results.</ncx:presence>
                <ncx:root/>
              </xs:appinfo>
            </xs:annotation>
            <xs:complexType>
              <xs:sequence>
                <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 name="get" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Retrieve running configuration and device state information.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>get_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 7.7</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="filter" minOccurs="0">
              <xs:annotation>
                <xs:documentation>This parameter specifies the portion of the system
                  configuration and state data to retrieve.  If this parameter is
                  empty, all the device configuration and state information is
                  returned.
                  
                  The filter element may optionally contain a 'type' attribute.
                  This attribute indicates the type of filtering syntax used
                  within the filter element.  The default filtering mechanism in
                  NETCONF is referred to as subtree filtering and is described in
                  Section 6.  The value 'subtree' explicitly identifies this type
                  of filtering.
                  
                  If the NETCONF peer supports the :xpath capability
                  (Section 8.9), the value 'xpath' may be used to indicate that
                  the select attribute of the filter element contains an XPath
                  expression.</xs:documentation>
                <xs:appinfo>
                  <nc:get-filter-element-attributes/>
                  <ncx:metadata>
                    <ncx:syntax-string>FilterType type</ncx:syntax-string>
                  </ncx:metadata>
                  <ncx:metadata>
                    <ncx:syntax-string>string select</ncx:syntax-string>
                  </ncx:metadata>
                </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>
  <xs:complexType name="close-session_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="close-session" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Request graceful termination of a NETCONF session.
        
        When a NETCONF server receives a &lt;close-session&gt; request, it will
        gracefully close the session.  The server will release any locks
        and resources associated with the session and gracefully close any
        associated connections.  Any NETCONF requests received after a
        'close-session' request will be ignored.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>close-session_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 7.8</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </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="kill-session_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="kill-session" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Force the termination of a NETCONF session.
        
        When a NETCONF entity receives a &lt;kill-session&gt; request for an
        open session, it will abort any operations currently in process,
        release any locks and resources associated with the session, and
        close any associated connections.
        
        If a NETCONF server receives a &lt;kill-session&gt; request while
        processing a confirmed commit (Section 8.4), it must restore the
        configuration to its state before the confirmed commit was issued.
        
        Otherwise, the &lt;kill-session&gt; operation does not roll back
        configuration or other device state modifications made by the
        entity holding the lock.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>kill-session_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 7.9</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="session-id" type="session-id-type">
              <xs:annotation>
                <xs:documentation>Particular session to kill.</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="commit_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="commit" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>When a candidate configuration's content is complete, the
        configuration data can be committed, publishing the data set to
        the rest of the device and requesting the device to conform to
        the behavior described in the new configuration.
        
        To commit the candidate configuration as the device's new
        current configuration, use the &lt;commit&gt; operation.
        
        The 'commit' operation instructs the device to implement the
        configuration data contained in the candidate configuration.
        If the device is unable to commit all of the changes in the
        candidate configuration datastore, then the running
        configuration MUST remain unchanged.  If the device does
        succeed in committing, the running configuration MUST be
        updated with the contents of the candidate configuration.
        
        If the system does not have the :candidate capability, the
        'commit' operation is not available.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>commit_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 8.3.4.1</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="confirmed" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Request a confirmed commit.</xs:documentation>
                <xs:appinfo>
                  <ncx:reference>
                    <ncx:text>RFC 4741, section 8.4.5.1</ncx:text>
                    <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
                  </ncx:reference>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="confirm-timeout"
              type="ConfirmTimeoutType" default="600" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Request a specific timeout period for a confirmed commit
                  if 'confirmed-commit' capability supported.</xs:documentation>
                <xs:appinfo>
                  <ncx:units>seconds</ncx:units>
                  <ncx:reference>
                    <ncx:text>RFC 4741, section 8.4.5.1</ncx:text>
                    <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
                  </ncx:reference>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="persist" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>This parameter is used to make a confirmed commit
                  persistent.  A persistent confirmed commit is not aborted
                  if the NETCONF session terminates.  The only way to abort a
                  persistent confirmed commit it to let the timer expire, or
                  to use the cancel-commit operation.
                  
                  The value of this parameter is a token that must be given
                  in the 'persist-id' parameter of commit or cancel-commit in
                  order to confirm or cancel the persistent confirmed commit.
                  
                  The token should be a random string.</xs:documentation>
                <xs:appinfo>
                  <ncx:reference>
                    <ncx:text>RFC 6241, section 8.3.4.1.</ncx:text>
                    <ncx:url>http://www.ietf.org/rfc/rfc6241.txt</ncx:url>
                  </ncx:reference>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="persist-id" type="xs:string"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>This parameter is given in order to commit a persistent
                  confirmed commit.  The value must be equal to the value
                  given in the 'persist' parameter to the commit operation.
                  If it does not match, the operation fails with an
                  'invalid-value' error.</xs:documentation>
                <xs:appinfo>
                  <ncx:reference>
                    <ncx:text>RFC 6241, section 8.3.4.1.</ncx:text>
                    <ncx:url>http://www.ietf.org/rfc/rfc6241.txt</ncx:url>
                  </ncx:reference>
                </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="discard-changes_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="discard-changes"
    substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>If the client decides that the candidate configuration should
        not be committed, the 'discard-changes' operation can be used
        to revert the candidate configuration to the current running
        configuration.
        
        This operation discards any uncommitted changes by resetting
        the candidate configuration with the content of the running
        configuration.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>discard-changes_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 8.3.4.2</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </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="cancel-commit_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="cancel-commit" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>This operation is used to cancel an ongoing confirmed commit.
        If the confirmed commit is persistent, the parameter
        'persist-id' must be given, and it must match the value of the
        'persist' parameter.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>cancel-commit_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 6241, section 8.4.4.1.</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc6241.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="persist-id" type="xs:string"
              minOccurs="0">
              <xs:annotation>
                <xs:documentation>This parameter is given in order to cancel a persistent
                  confirmed commit.  The value must be equal to the value
                  given in the 'persist' parameter to the commit operation.
                  If it does not match, the operation fails with an
                  'invalid-value' error.</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="validate_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="validate" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>Validates the contents of the specified configuration.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>validate_output_type__</ncx:rpc-output>
        <ncx:reference>
          <ncx:text>RFC 4741, section 8.6.4.1</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="source">
              <xs:annotation>
                <xs:documentation>Particular configuration to validate.</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: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: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="inet:uri"
                        minOccurs="0"/>
                      <xs:any minOccurs="0" maxOccurs="unbounded"
                        namespace="##other" processContents="lax"/>
                    </xs:sequence>
                    <xs:sequence>
                      <xs:annotation>
                        <xs:appinfo>
                          <ncx:case-name>config</ncx:case-name>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:element name="config">
                        <xs:annotation>
                          <xs:documentation>Inline Config content: 'config' element.
                            Represents an entire 'stand-alone'
                            configuration database, not a subset of
                            the running database.</xs:documentation>
                          <xs:appinfo>
                            <ncx:config>true</ncx:config>
                            <ncx:root/>
                          </xs:appinfo>
                        </xs:annotation>
                        <xs:complexType>
                          <xs:sequence>
                            <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: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:element name="config">
    <xs:annotation>
      <xs:documentation>Used as the container for NETCONF object definitions.</xs:documentation>
      <xs:appinfo>
        <ncx:config>true</ncx:config>
        <ncx:root/>
        <ncx:abstract/>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"
          processContents="lax"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

