<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           xmlns:ys="urn:ietf:params:xml:schema:yang:yin:1"
           targetNamespace="urn:ietf:params:xml:ns:yang:yang-types"
           xmlns="urn:ietf:params:xml:ns:yang:yang-types"
           xmlns:yang="urn:ietf:params:xml:ns:yang:yang-types"
           elementFormDefault="qualified"
           attributeFormDefault="unqualified"
           version="2007-10-02"
           xml:lang="en">

  <xs:annotation>
    <xs:documentation>
      This schema was generated from the YANG module yang-types
      by pyang version 00.1.

      The schema describes an instance document consisting of the
      entire configuration data store and operational data.  This
      schema can thus NOT be used as-is to validate NETCONF PDUs.
    </xs:documentation>
  </xs:annotation>

  <xs:annotation>
    <xs:documentation>
      This module contains standard derived YANG types.
    </xs:documentation>
    <xs:appinfo>
      <ys:prefix value="yang"/>
      <ys:organization>
        <ys:info>
          YANG Language Design Team
        </ys:info>
      </ys:organization>
      <ys:contact>
        <ys:info>
          Martin Bjorklund (Editor) &lt;mbj@tail-f.com&gt;
        </ys:info>
      </ys:contact>
      <ys:revision date="2007-10-02">
        <ys:description>
          <ys:text>
            Initial revision.
          </ys:text>
        </ys:description>
      </ys:revision>
    </xs:appinfo>
  </xs:annotation>

  <!-- YANG typedefs -->

  <xs:simpleType name="counter32">
    <xs:annotation>
      <xs:documentation>
        The counter32 type represents a non-negative integer
        which monotonically increases until it reaches a
        maximum value of 2^32-1 (4294967295 decimal), when it
        wraps around and starts increasing again from zero.

        Counters have no defined `initial' value, and thus, a
        single value of a counter has (in general) no information
        content.  Discontinuities in the monotonically increasing
        value normally occur at re-initialization of the
        management system, and at other times as specified in the
        description of an object instance using this type.  If
        such other times can occur, for example, the creation of
        an object instance of type counter32 at times other than
        re-initialization, then a corresponding object should be
        defined, with an appropriate type, to indicate the last
        discontinuity.

        The counter32 type should not be used for configuration
        objects. A default statement should not be used for
        attributes with a type value of counter32.
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="xs:unsignedInt">
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="zero-based-counter32">
    <xs:annotation>
      <xs:documentation>
        The zero-based-counter32 type represents a counter32
        which has the defined `initial' value zero.
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="yang:counter32">
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="counter64">
    <xs:annotation>
      <xs:documentation>
        The counter64 type represents a non-negative integer
        which monotonically increases until it reaches a
        maximum value of 2^64-1 (18446744073709551615), when
        it wraps around and starts increasing again from zero.

        Counters have no defined `initial' value, and thus, a
        single value of a counter has (in general) no information
        content.  Discontinuities in the monotonically increasing
        value normally occur at re-initialization of the
        management system, and at other times as specified in the
        description of an object instance using this type.  If
        such other times can occur, for example, the creation of
        an object instance of type counter64 at times other than
        re-initialization, then a corresponding object should be
        defined, with an appropriate type, to indicate the last
        discontinuity.

        The counter64 type should not be used for configuration
        objects. A default statement should not be used for
        attributes with a type value of counter64.
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="xs:unsignedLong">
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="zero-based-counter64">
    <xs:annotation>
      <xs:documentation>
        The zero-based-counter64 type represents a counter64
        which has the defined `initial' value zero.
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="yang:counter64">
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="gauge32">
    <xs:annotation>
      <xs:documentation>
        The gauge32 type represents a non-negative integer,
        which may increase or decrease, but shall never
        exceed a maximum value, nor fall below a minimum
        value.  The maximum value can not be greater than
        2^32-1 (4294967295 decimal), and the minimum value
        can not be smaller than 0.  The value of a gauge32
        has its maximum value whenever the information
        being modeled is greater than or equal to its
        maximum value, and has its minimum value whenever
        the information being modeled is smaller than or
        equal to its minimum value.  If the information
        being modeled subsequently decreases below
        (increases above) the maximum (minimum) value, the
        gauge32 also decreases (increases).
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="xs:unsignedInt">
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="gauge64">
    <xs:annotation>
      <xs:documentation>
        The gauge64 type represents a non-negative integer,
        which may increase or decrease, but shall never
        exceed a maximum value, nor fall below a minimum
        value.  The maximum value can not be greater than
        2^64-1 (18446744073709551615), and the minimum value
        can not be smaller than 0.  The value of a gauge64
        has its maximum value whenever the information
        being modeled is greater than or equal to its
        maximum value, and has its minimum value whenever
        the information being modeled is smaller than or
        equal to its minimum value.  If the information
        being modeled subsequently decreases below
        (increases above) the maximum (minimum) value, the
        gauge64 also decreases (increases).
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="xs:unsignedLong">
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="uri">
    <xs:annotation>
      <xs:documentation>
        A uri type represents Uniform Resource Identifier (URI) 
        as defined by STD 66.

        Objects using this type MUST be in US-ASCII encoding, and
        MUST be normalized as described by RFC 3986 Sections
        6.2.1, 6.2.2.1, and 6.2.2.2.  All unnecessary
        percent-encoding is removed, and all case-insensitive
        characters are set to lowercase except for hexadecimal
        digits, which are normalized to uppercase as described in
        Section 6.2.2.1.

        The purpose of this normalization is to help provide unique
        URIs.  Note that this normalization is not sufficient to
        provide uniqueness.  Two URIs that are textually distinct
        after this normalization may still be equivalent.

        Objects using this type MAY restrict the schemes that they
        permit.  For example, 'data:' and 'urn:' schemes might not
        be appropriate.

        A zero-length URI is not a valid URI.  This can be used to
        express 'URI absent' where required, for example when used
        as an index field.
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="xs:string">
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="object-identifier">
    <xs:annotation>
      <xs:documentation>
        The object-identifier type represents administratively
        assigned names in a registration-hierarchical-name tree.
          
        Values of this type are denoted as a sequence of numerical
        non-negative sub-identifier values. Each sub-identifier
        value MUST NOT exceed 2^32-1 (4294967295). Sub-identifiers
        are separated by single dots and without any intermediate
        white space.

        Although the number of sub-identifiers is not limited,
        module designers should realize that there may be
        implementations that stick with the SMIv1/v2 limit of 128
        sub-identifiers.
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="xs:string">
      <xs:pattern value="[0-2](\.\d+)+"/>
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="date-and-time">
    <xs:annotation>
      <xs:documentation>
        The date-and-time type is a profile of the ISO 8601
                    standard for representation of dates and times using the
                    Gregorian calendar. The format is most easily described
                    using the following ABFN (see RFC 3339):

                    date-fullyear   = 4DIGIT
                    date-month      = 2DIGIT  ; 01-12
                    date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31
                    time-hour       = 2DIGIT  ; 00-23
                    time-minute     = 2DIGIT  ; 00-59
                    time-second     = 2DIGIT  ; 00-58, 00-59, 00-60
                    time-secfrac    = "." 1*DIGIT
                    time-numoffset  = ("+" / "-") time-hour ":" time-minute
                    time-offset     = "Z" / time-numoffset

                    partial-time    = time-hour ":" time-minute ":" time-second
                                      [time-secfrac]
                    full-date       = date-fullyear "-" date-month "-" date-mday
                    full-time       = partial-time time-offset

                    date-time       = full-date "T" full-time
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="xs:string">
      <xs:pattern value="\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.d*)?(Z|(\+|-)\d{2}:\d{2})"/>
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="timeticks">
    <xs:annotation>
      <xs:documentation>
        The timeticks type represents a non-negative integer
        which represents the time, modulo 2^32 (4294967296
        decimal), in hundredths of a second between two epochs.
        When objects are defined which use this type, the
        description of the object identifies both of the reference
        epochs.
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="xs:unsignedInt">
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="timestamp">
    <xs:annotation>
      <xs:documentation>
        The timestamp type represents the value of an associated
        timeticks object at which a specific occurrence
        happened.  The specific occurrence must be defined in the
        description of any object defined using this type.  When
        the specific occurrence occurred prior to the last time
        the associated timeticks attribute was zero, then the
        timestamp value is zero.  Note that this requires all
        timestamp values to be reset to zero when the value of
        the associated timeticks attribute reaches 497+ days and
        wraps around to zero.

        The associated timeticks object must be specified
        in the description of any object using this type.
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="yang:timeticks">
    </xs:restriction>
  </xs:simpleType>

  <xs:simpleType name="phys-address">
    <xs:annotation>
      <xs:documentation>
        Represents media- or physical-level addresses.
      </xs:documentation>
    </xs:annotation>

    <xs:restriction base="xs:string">
    </xs:restriction>
  </xs:simpleType>

</xs:schema>