<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns="urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring"
  targetNamespace="urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring"
  elementFormDefault="qualified" attributeFormDefault="unqualified"
  xml:lang="en" version="2010-10-04"
  xmlns:ncx="http://netconfcentral.org/ns/yuma-ncx"
  xmlns:nc="urn:ietf:params:xml:ns:netconf:base:1.0"
  xmlns:yang="urn:ietf:params:xml:ns:yang:ietf-yang-types"
  xmlns:inet="urn:ietf:params:xml:ns:yang:ietf-inet-types">
  <xs:annotation>
    <xs:documentation>Converted from YANG file 'ietf-netconf-monitoring.yang' by yangdump version 2.2.1737
      
      Module: ietf-netconf-monitoring
      Organization: IETF NETCONF (Network Configuration) Working Group
      Version: 2010-10-04
      Contact: WG Web:   &lt;http://tools.ietf.org/wg/netconf/&gt;
      WG List:  &lt;mailto:netconf@ietf.org&gt;
      
      WG Chair: Mehmet Ersue
      	  &lt;mailto:mehmet.ersue@nsn.com&gt;
      
      WG Chair: Bert Wijnen
      	  &lt;mailto:bertietf@bwijnen.net&gt;
      
      Editor:   Mark Scott
      	  &lt;mailto:mark.scott@ericsson.com&gt;
      
      Editor:   Martin Bjorklund
      	  &lt;mailto:mbj@tail-f.com&gt;</xs:documentation>
    <xs:documentation>NETCONF Monitoring Module.
      All elements in this module are read-only.
      
      Copyright (c) 2010 IETF Trust and the persons identified as
      authors of the code. All rights reserved.
      
      Redistribution and use in source and binary forms, with or
      without modification, is permitted pursuant to, and subject
      to the license terms contained in, the Simplified BSD
      License set forth in Section 4.c of the IETF Trust's
      Legal Provisions Relating to IETF Documents
      (http://trustee.ietf.org/license-info).
      
      This version of this YANG module is part of RFC 6022; see
      the RFC itself for full legal notices.</xs:documentation>
    <xs:appinfo>
      <ncx:source>/usr/share/yuma/modules/ietf/ietf-netconf-monitoring.yang</ncx:source>
      <ncx:organization>IETF NETCONF (Network Configuration) Working Group</ncx:organization>
      <ncx:contact>WG Web:   &lt;http://tools.ietf.org/wg/netconf/&gt;
        WG List:  &lt;mailto:netconf@ietf.org&gt;
        
        WG Chair: Mehmet Ersue
        	  &lt;mailto:mehmet.ersue@nsn.com&gt;
        
        WG Chair: Bert Wijnen
        	  &lt;mailto:bertietf@bwijnen.net&gt;
        
        Editor:   Mark Scott
        	  &lt;mailto:mark.scott@ericsson.com&gt;
        
        Editor:   Martin Bjorklund
        	  &lt;mailto:mbj@tail-f.com&gt;</ncx:contact>
    </xs:appinfo>
    <xs:appinfo>
      <ncx:revision>
        <ncx:version>2010-10-04</ncx:version>
        <ncx:description>Initial revision.</ncx:description>
      </ncx:revision>
    </xs:appinfo>
  </xs:annotation>
  <xs:simpleType name="netconf-datastore-type">
    <xs:annotation>
      <xs:documentation>Enumeration of possible NETCONF datastore types.</xs:documentation>
      <xs:appinfo>
        <ncx:reference>
          <ncx:text>RFC 4741: NETCONF Configuration Protocol</ncx:text>
          <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
        </ncx:reference>
      </xs:appinfo>
    </xs:annotation>
    <xs:restriction base="xs:string">
      <xs:enumeration value="running">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>0</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="candidate">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>1</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
      <xs:enumeration value="startup">
        <xs:annotation>
          <xs:appinfo>
            <ncx:value>2</ncx:value>
          </xs:appinfo>
        </xs:annotation>
      </xs:enumeration>
    </xs:restriction>
  </xs:simpleType>
  <xs:group name="common-counters">
    <xs:annotation>
      <xs:documentation>Counters that exist both per session, and also globally,
        accumulated from all sessions.</xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="in-rpcs" type="yang:zero-based-counter32"
        default="0" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Number of correct &lt;rpc&gt; messages received.</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name="in-bad-rpcs" type="yang:zero-based-counter32"
        default="0" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Number of messages received when an &lt;rpc&gt; message was expected,
            that were not correct &lt;rpc&gt; messages.  This includes XML parse
            errors and errors on the rpc layer.</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name="out-rpc-errors"
        type="yang:zero-based-counter32" default="0" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Number of &lt;rpc-reply&gt; messages sent that contained an
            &lt;rpc-error&gt; element.</xs:documentation>
        </xs:annotation>
      </xs:element>
      <xs:element name="out-notifications"
        type="yang:zero-based-counter32" default="0" minOccurs="0">
        <xs:annotation>
          <xs:documentation>Number of &lt;notification&gt; messages sent.</xs:documentation>
        </xs:annotation>
      </xs:element>
    </xs:sequence>
  </xs:group>
  <xs:element name="netconf-state">
    <xs:annotation>
      <xs:documentation>The netconf-state container is the root of the monitoring
        data model.</xs:documentation>
      <xs:appinfo>
        <ncx:config>false</ncx:config>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element name="capabilities">
          <xs:annotation>
            <xs:documentation>Contains the list of NETCONF capabilities supported by the
              server.</xs:documentation>
          </xs:annotation>
          <xs:complexType>
            <xs:sequence>
              <xs:element name="capability" type="inet:uri"
                minOccurs="0" maxOccurs="unbounded">
                <xs:annotation>
                  <xs:documentation>List of NETCONF capabilities supported by the server.</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:element name="datastores">
          <xs:annotation>
            <xs:documentation>Contains the list of NETCONF configuration datastores.</xs:documentation>
          </xs:annotation>
          <xs:complexType>
            <xs:sequence>
              <xs:element name="datastore" minOccurs="0"
                maxOccurs="unbounded">
                <xs:annotation>
                  <xs:documentation>List of NETCONF configuration datastores supported by
                    the NETCONF server and related information.</xs:documentation>
                  <xs:appinfo>
                    <ncx:ordered-by>system</ncx:ordered-by>
                  </xs:appinfo>
                </xs:annotation>
                <xs:complexType>
                  <xs:sequence>
                    <xs:element name="name"
                      type="netconf-datastore-type">
                      <xs:annotation>
                        <xs:documentation>Name of the datastore associated with this list entry.</xs:documentation>
                      </xs:annotation>
                    </xs:element>
                    <xs:element name="locks">
                      <xs:annotation>
                        <xs:documentation>The NETCONF &lt;lock&gt; and &lt;partial-lock&gt; operations allow
                          a client to lock specific resources in a datastore.  The
                          NETCONF server will prevent changes to the locked
                          resources by all sessions except the one that acquired
                          the lock(s).
                          
                          Monitoring information is provided for each datastore
                          entry including details such as the session that acquired
                          the lock, the type of lock (global or partial) and the
                          list of locked resources.  Multiple locks per datastore
                          are supported.</xs:documentation>
                        <xs:appinfo>
                          <ncx:presence>This container is present only if the datastore
                            is locked.</ncx:presence>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:complexType>
                        <xs:sequence>
                          <xs:choice>
                            <xs:annotation>
                              <xs:documentation>Indicates if a global lock or a set of partial locks
                                are set.</xs:documentation>
                              <xs:appinfo>
                                <ncx:choice-name>lock-type</ncx:choice-name>
                              </xs:appinfo>
                            </xs:annotation>
                            <xs:sequence>
                              <xs:annotation>
                                <xs:appinfo>
                                  <ncx:case-name>global-lock</ncx:case-name>
                                </xs:appinfo>
                              </xs:annotation>
                              <xs:element name="global-lock">
                                <xs:annotation>
                                  <xs:documentation>Present if the global lock is set.</xs:documentation>
                                </xs:annotation>
                                <xs:complexType>
                                  <xs:sequence>
                                    <xs:element
                                      name="locked-by-session"
                                      type="xs:unsignedInt">
                                      <xs:annotation>
                                        <xs:documentation>The session ID of the session that has locked
                                          this resource.  Both a global lock and a partial
                                          lock MUST contain the NETCONF session-id.
                                          
                                          If the lock is held by a session that is not managed
                                          by the NETCONF server (e.g., a CLI session), a session
                                          id of 0 (zero) is reported.</xs:documentation>
                                        <xs:appinfo>
                                          <ncx:mandatory>true</ncx:mandatory>
                                          <ncx:reference>
                                            <ncx:text>RFC 4741: NETCONF Configuration Protocol</ncx:text>
                                            <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
                                          </ncx:reference>
                                        </xs:appinfo>
                                      </xs:annotation>
                                    </xs:element>
                                    <xs:element name="locked-time"
                                      type="yang:date-and-time">
                                      <xs:annotation>
                                        <xs:documentation>The date and time of when the resource was
                                          locked.</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:complexType>
                              </xs:element>
                              <xs:any minOccurs="0"
                                maxOccurs="unbounded"
                                namespace="##other"
                                processContents="lax"/>
                            </xs:sequence>
                            <xs:sequence>
                              <xs:annotation>
                                <xs:appinfo>
                                  <ncx:case-name>partial-lock</ncx:case-name>
                                </xs:appinfo>
                              </xs:annotation>
                              <xs:element name="partial-lock"
                                minOccurs="0" maxOccurs="unbounded">
                                <xs:annotation>
                                  <xs:documentation>List of partial locks.</xs:documentation>
                                  <xs:appinfo>
                                    <ncx:ordered-by>system</ncx:ordered-by>
                                    <ncx:reference>
                                      <ncx:text>RFC 5717: Partial Lock Remote Procedure Call (RPC) for
                                        	  NETCONF</ncx:text>
                                      <ncx:url>http://www.ietf.org/rfc/rfc5717.txt</ncx:url>
                                    </ncx:reference>
                                  </xs:appinfo>
                                </xs:annotation>
                                <xs:complexType>
                                  <xs:sequence>
                                    <xs:element name="lock-id"
                                      type="xs:unsignedInt">
                                      <xs:annotation>
                                        <xs:documentation>This is the lock id returned in the &lt;partial-lock&gt;
                                          response.</xs:documentation>
                                      </xs:annotation>
                                    </xs:element>
                                    <xs:element
                                      name="locked-by-session"
                                      type="xs:unsignedInt">
                                      <xs:annotation>
                                        <xs:documentation>The session ID of the session that has locked
                                          this resource.  Both a global lock and a partial
                                          lock MUST contain the NETCONF session-id.
                                          
                                          If the lock is held by a session that is not managed
                                          by the NETCONF server (e.g., a CLI session), a session
                                          id of 0 (zero) is reported.</xs:documentation>
                                        <xs:appinfo>
                                          <ncx:mandatory>true</ncx:mandatory>
                                          <ncx:reference>
                                            <ncx:text>RFC 4741: NETCONF Configuration Protocol</ncx:text>
                                            <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
                                          </ncx:reference>
                                        </xs:appinfo>
                                      </xs:annotation>
                                    </xs:element>
                                    <xs:element name="locked-time"
                                      type="yang:date-and-time">
                                      <xs:annotation>
                                        <xs:documentation>The date and time of when the resource was
                                          locked.</xs:documentation>
                                        <xs:appinfo>
                                          <ncx:mandatory>true</ncx:mandatory>
                                        </xs:appinfo>
                                      </xs:annotation>
                                    </xs:element>
                                    <xs:element name="select"
                                      type="yang:xpath1.0"
                                      minOccurs="1"
                                      maxOccurs="unbounded">
                                      <xs:annotation>
                                        <xs:documentation>The xpath expression that was used to request
                                          the lock.  The select expression indicates the
                                          original intended scope of the lock.</xs:documentation>
                                        <xs:appinfo>
                                          <ncx:ordered-by>system</ncx:ordered-by>
                                        </xs:appinfo>
                                      </xs:annotation>
                                    </xs:element>
                                    <xs:element name="locked-node"
                                      type="xs:string" minOccurs="0"
                                      maxOccurs="unbounded">
                                      <xs:annotation>
                                        <xs:documentation>The list of instance-identifiers (i.e., the
                                          locked nodes).
                                          
                                          The scope of the partial lock is defined by the list
                                          of locked nodes.</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:key name="partial-lockkey10">
                                  <xs:selector xpath="."/>
                                  <xs:field xpath="lock-id"/>
                                </xs:key>
                              </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:complexType>
                <xs:key name="datastorekey11">
                  <xs:selector xpath="."/>
                  <xs:field xpath="name"/>
                </xs:key>
              </xs:element>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name="schemas">
          <xs:annotation>
            <xs:documentation>Contains the list of data model schemas supported by the
              server.</xs:documentation>
          </xs:annotation>
          <xs:complexType>
            <xs:sequence>
              <xs:element name="schema" minOccurs="0"
                maxOccurs="unbounded">
                <xs:annotation>
                  <xs:documentation>List of data model schemas supported by the server.</xs:documentation>
                  <xs:appinfo>
                    <ncx:ordered-by>system</ncx:ordered-by>
                  </xs:appinfo>
                </xs:annotation>
                <xs:complexType>
                  <xs:sequence>
                    <xs:element name="identifier" type="xs:string">
                      <xs:annotation>
                        <xs:documentation>Identifier to uniquely reference the schema.  The
                          identifier is used in the &lt;get-schema&gt; operation and may
                          be used for other purposes such as file retrieval.
                          
                          For modeling languages that support or require a data
                          model name (e.g., YANG module name) the identifier MUST
                          match that name.  For YANG data models, the identifier is
                          the name of the module or submodule.  In other cases, an
                          identifier such as a filename MAY be used instead.</xs:documentation>
                      </xs:annotation>
                    </xs:element>
                    <xs:element name="version" type="xs:string">
                      <xs:annotation>
                        <xs:documentation>Version of the schema supported.  Multiple versions MAY be
                          supported simultaneously by a NETCONF server.  Each
                          version MUST be reported individually in the schema list,
                          i.e., with same identifier, possibly different location,
                          but different version.
                          
                          For YANG data models, version is the value of the most
                          recent YANG 'revision' statement in the module or
                          submodule, or the empty string if no 'revision' statement
                          is present.</xs:documentation>
                      </xs:annotation>
                    </xs:element>
                    <xs:element name="format" type="xs:QName">
                      <xs:annotation>
                        <xs:documentation>The data modeling language the schema is written
                          in (currently xsd, yang, yin, rng, or rnc).
                          For YANG data models, 'yang' format MUST be supported and
                          'yin' format MAY also be provided.</xs:documentation>
                      </xs:annotation>
                    </xs:element>
                    <xs:element name="namespace" type="inet:uri">
                      <xs:annotation>
                        <xs:documentation>The XML namespace defined by the data model.
                          
                          For YANG data models, this is the module's namespace.
                          If the list entry describes a submodule, this field
                          contains the namespace of the module to which the
                          submodule belongs.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                        </xs:appinfo>
                      </xs:annotation>
                    </xs:element>
                    <xs:element name="location" minOccurs="0"
                      maxOccurs="unbounded">
                      <xs:annotation>
                        <xs:documentation>One or more locations from which the schema can be
                          retrieved.  This list SHOULD contain at least one
                          entry per schema.
                          
                          A schema entry may be located on a remote file system
                          (e.g., reference to file system for ftp retrieval) or
                          retrieved directly from a server supporting the
                          &lt;get-schema&gt; operation (denoted by the value 'NETCONF').</xs:documentation>
                        <xs:appinfo>
                          <ncx:ordered-by>system</ncx:ordered-by>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:simpleType>
                        <xs:union>
                          <xs:simpleType>
                            <xs:restriction base="xs:string">
                              <xs:enumeration value="NETCONF">
                                <xs:annotation>
                                  <xs:appinfo>
                                    <ncx:value>0</ncx:value>
                                  </xs:appinfo>
                                </xs:annotation>
                              </xs:enumeration>
                            </xs:restriction>
                          </xs:simpleType>
                          <xs:simpleType>
                            <xs:restriction base="inet:uri"/>
                          </xs:simpleType>
                        </xs:union>
                      </xs:simpleType>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                </xs:complexType>
                <xs:key name="schemakey12">
                  <xs:selector xpath="."/>
                  <xs:field xpath="identifier"/>
                  <xs:field xpath="version"/>
                  <xs:field xpath="format"/>
                </xs:key>
              </xs:element>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name="sessions">
          <xs:annotation>
            <xs:documentation>The sessions container includes session-specific data for
              NETCONF management sessions.  The session list MUST include
              all currently active NETCONF sessions.</xs:documentation>
          </xs:annotation>
          <xs:complexType>
            <xs:sequence>
              <xs:element name="session" minOccurs="0"
                maxOccurs="unbounded">
                <xs:annotation>
                  <xs:documentation>All NETCONF sessions managed by the NETCONF server
                    MUST be reported in this list.</xs:documentation>
                  <xs:appinfo>
                    <ncx:ordered-by>system</ncx:ordered-by>
                  </xs:appinfo>
                </xs:annotation>
                <xs:complexType>
                  <xs:sequence>
                    <xs:element name="session-id">
                      <xs:annotation>
                        <xs:documentation>Unique identifier for the session.  This value is the
                          NETCONF session identifier, as defined in RFC 4741.</xs:documentation>
                        <xs:appinfo>
                          <ncx:reference>
                            <ncx:text>RFC 4741: NETCONF Configuration Protocol</ncx:text>
                            <ncx:url>http://www.ietf.org/rfc/rfc4741.txt</ncx:url>
                          </ncx:reference>
                        </xs:appinfo>
                      </xs:annotation>
                      <xs:simpleType>
                        <xs:restriction base="xs:unsignedInt">
                          <xs:minInclusive value="1"/>
                        </xs:restriction>
                      </xs:simpleType>
                    </xs:element>
                    <xs:element name="transport" type="xs:QName">
                      <xs:annotation>
                        <xs:documentation>Identifies the transport for each session, e.g.,
                          'netconf-ssh', 'netconf-soap', etc.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                        </xs:appinfo>
                      </xs:annotation>
                    </xs:element>
                    <xs:element name="username" type="xs:string">
                      <xs:annotation>
                        <xs:documentation>The username is the client identity that was authenticated
                          by the NETCONF transport protocol.  The algorithm used to
                          derive the username is NETCONF transport protocol specific
                          and in addition specific to the authentication mechanism
                          used by the NETCONF transport protocol.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                        </xs:appinfo>
                      </xs:annotation>
                    </xs:element>
                    <xs:element name="source-host" type="inet:host"
                      minOccurs="0">
                      <xs:annotation>
                        <xs:documentation>Host identifier of the NETCONF client.  The value
                          returned is implementation specific (e.g., hostname,
                          IPv4 address, IPv6 address)</xs:documentation>
                      </xs:annotation>
                      <xs:simpleType>
                        <xs:union
                          memberTypes="inet:ip-address&#32;inet:domain-name"/>
                      </xs:simpleType>
                    </xs:element>
                    <xs:element name="login-time"
                      type="yang:date-and-time">
                      <xs:annotation>
                        <xs:documentation>Time at the server at which the session was established.</xs:documentation>
                        <xs:appinfo>
                          <ncx:mandatory>true</ncx:mandatory>
                        </xs:appinfo>
                      </xs:annotation>
                    </xs:element>
                    <xs:element name="in-rpcs"
                      type="yang:zero-based-counter32" default="0"
                      minOccurs="0">
                      <xs:annotation>
                        <xs:documentation>Number of correct &lt;rpc&gt; messages received.</xs:documentation>
                      </xs:annotation>
                    </xs:element>
                    <xs:element name="in-bad-rpcs"
                      type="yang:zero-based-counter32" default="0"
                      minOccurs="0">
                      <xs:annotation>
                        <xs:documentation>Number of messages received when an &lt;rpc&gt; message was expected,
                          that were not correct &lt;rpc&gt; messages.  This includes XML parse
                          errors and errors on the rpc layer.</xs:documentation>
                      </xs:annotation>
                    </xs:element>
                    <xs:element name="out-rpc-errors"
                      type="yang:zero-based-counter32" default="0"
                      minOccurs="0">
                      <xs:annotation>
                        <xs:documentation>Number of &lt;rpc-reply&gt; messages sent that contained an
                          &lt;rpc-error&gt; element.</xs:documentation>
                      </xs:annotation>
                    </xs:element>
                    <xs:element name="out-notifications"
                      type="yang:zero-based-counter32" default="0"
                      minOccurs="0">
                      <xs:annotation>
                        <xs:documentation>Number of &lt;notification&gt; messages sent.</xs:documentation>
                      </xs:annotation>
                    </xs:element>
                    <xs:any minOccurs="0" maxOccurs="unbounded"
                      namespace="##other" processContents="lax"/>
                  </xs:sequence>
                </xs:complexType>
                <xs:key name="sessionkey13">
                  <xs:selector xpath="."/>
                  <xs:field xpath="session-id"/>
                </xs:key>
              </xs:element>
              <xs:any minOccurs="0" maxOccurs="unbounded"
                namespace="##other" processContents="lax"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name="statistics">
          <xs:annotation>
            <xs:documentation>Statistical data pertaining to the NETCONF server.</xs:documentation>
          </xs:annotation>
          <xs:complexType>
            <xs:sequence>
              <xs:element name="netconf-start-time"
                type="yang:date-and-time" minOccurs="0">
                <xs:annotation>
                  <xs:documentation>Date and time at which the management subsystem was
                    started.</xs:documentation>
                </xs:annotation>
              </xs:element>
              <xs:element name="in-bad-hellos"
                type="yang:zero-based-counter32" default="0"
                minOccurs="0">
                <xs:annotation>
                  <xs:documentation>Number of sessions silently dropped because an
                    invalid &lt;hello&gt; message was received.  This includes &lt;hello&gt;
                    messages with a 'session-id' attribute, bad namespace, and
                    bad capability declarations.</xs:documentation>
                </xs:annotation>
              </xs:element>
              <xs:element name="in-sessions"
                type="yang:zero-based-counter32" default="0"
                minOccurs="0">
                <xs:annotation>
                  <xs:documentation>Number of sessions started.  This counter is incremented
                    when a &lt;hello&gt; message with a &lt;session-id&gt; is sent.
                    
                    'in-sessions' - 'in-bad-hellos' =
                       'number of correctly started netconf sessions'</xs:documentation>
                </xs:annotation>
              </xs:element>
              <xs:element name="dropped-sessions"
                type="yang:zero-based-counter32" default="0"
                minOccurs="0">
                <xs:annotation>
                  <xs:documentation>Number of sessions that were abnormally terminated, e.g.,
                    due to idle timeout or transport close.  This counter is not
                    incremented when a session is properly closed by a
                    &lt;close-session&gt; operation, or killed by a &lt;kill-session&gt;
                    operation.</xs:documentation>
                </xs:annotation>
              </xs:element>
              <xs:element name="in-rpcs"
                type="yang:zero-based-counter32" default="0"
                minOccurs="0">
                <xs:annotation>
                  <xs:documentation>Number of correct &lt;rpc&gt; messages received.</xs:documentation>
                </xs:annotation>
              </xs:element>
              <xs:element name="in-bad-rpcs"
                type="yang:zero-based-counter32" default="0"
                minOccurs="0">
                <xs:annotation>
                  <xs:documentation>Number of messages received when an &lt;rpc&gt; message was expected,
                    that were not correct &lt;rpc&gt; messages.  This includes XML parse
                    errors and errors on the rpc layer.</xs:documentation>
                </xs:annotation>
              </xs:element>
              <xs:element name="out-rpc-errors"
                type="yang:zero-based-counter32" default="0"
                minOccurs="0">
                <xs:annotation>
                  <xs:documentation>Number of &lt;rpc-reply&gt; messages sent that contained an
                    &lt;rpc-error&gt; element.</xs:documentation>
                </xs:annotation>
              </xs:element>
              <xs:element name="out-notifications"
                type="yang:zero-based-counter32" default="0"
                minOccurs="0">
                <xs:annotation>
                  <xs:documentation>Number of &lt;notification&gt; messages sent.</xs:documentation>
                </xs:annotation>
              </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:complexType>
  </xs:element>
  <xs:complexType name="get-schema_output_type__">
    <xs:complexContent>
      <xs:extension base="nc:dataInlineType">
        <xs:sequence>
          <xs:element name="data" minOccurs="0">
            <xs:annotation>
              <xs:documentation>Contains the schema content.</xs:documentation>
            </xs:annotation>
            <xs:complexType>
              <xs:complexContent>
                <xs:extension base="xs:anyType"/>
              </xs:complexContent>
            </xs:complexType>
          </xs:element>
          <xs:any minOccurs="0" maxOccurs="unbounded"
            namespace="##other" processContents="lax"/>
        </xs:sequence>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:element name="get-schema" substitutionGroup="nc:rpcOperation">
    <xs:annotation>
      <xs:documentation>This operation is used to retrieve a schema from the
        NETCONF server.
        
        Positive Response:
          The NETCONF server returns the requested schema.
        
        Negative Response:
          If requested schema does not exist, the &lt;error-tag&gt; is
          'invalid-value'.
        
          If more than one schema matches the requested parameters, the
          &lt;error-tag&gt; is 'operation-failed', and &lt;error-app-tag&gt; is
          'data-not-unique'.</xs:documentation>
      <xs:appinfo>
        <ncx:rpc-output>get-schema_output_type__</ncx:rpc-output>
      </xs:appinfo>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="nc:rpcOperationType">
          <xs:sequence>
            <xs:element name="identifier" type="xs:string">
              <xs:annotation>
                <xs:documentation>Identifier for the schema list entry.</xs:documentation>
                <xs:appinfo>
                  <ncx:mandatory>true</ncx:mandatory>
                </xs:appinfo>
              </xs:annotation>
            </xs:element>
            <xs:element name="version" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>Version of the schema requested.  If this parameter is not
                  present, and more than one version of the schema exists on
                  the server, a 'data-not-unique' error is returned, as
                  described above.</xs:documentation>
              </xs:annotation>
            </xs:element>
            <xs:element name="format" type="xs:QName" minOccurs="0">
              <xs:annotation>
                <xs:documentation>The data modeling language of the schema.  If this
                  parameter is not present, and more than one formats of
                  the schema exists on the server, a 'data-not-unique' error
                  is returned, as described above.</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:schema>

