package org.geotools.gml3.v3_2;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.TreeMap;

import org.geotools.feature.NameImpl;
import org.geotools.feature.type.AbstractLazyAttributeTypeImpl;
import org.geotools.feature.type.AbstractLazyComplexTypeImpl;
import org.geotools.feature.type.AttributeDescriptorImpl;
import org.geotools.feature.type.SchemaImpl;
import org.geotools.gml3.v3_2.gmd.GMDSchema;
import org.geotools.xlink.XLINKSchema;
import org.geotools.xs.XSSchema;
import org.opengis.feature.type.AttributeType;
import org.opengis.feature.type.ComplexType;
import org.opengis.feature.type.Name;
import org.opengis.feature.type.PropertyDescriptor;
import org.opengis.feature.type.Schema;

/**
 * 
 *
 * @source $URL$
 */
public class GMLSchema extends SchemaImpl {

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractCRSType"&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:IdentifiedObjectType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element maxOccurs="unbounded" minOccurs="0" ref="gml:domainOfValidity"/&gt;
     *                  &lt;element maxOccurs="unbounded" ref="gml:scope"/&gt;
     *              &lt;/sequence&gt;
     *          &lt;/extension&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTCRSTYPE_TYPE = build_ABSTRACTCRSTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTCRSTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractCRSType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return IDENTIFIEDOBJECTTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        _DOMAINOFVALIDITY_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","domainOfValidity"),
                        0, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.STRING_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","scope"),
                        1, 2147483647, false, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractContinuousCoverageType"&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:AbstractCoverageType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element minOccurs="0" ref="gml:coverageFunction"/&gt;
     *              &lt;/sequence&gt;
     *          &lt;/extension&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTCONTINUOUSCOVERAGETYPE_TYPE = build_ABSTRACTCONTINUOUSCOVERAGETYPE_TYPE();
    
    private static ComplexType build_ABSTRACTCONTINUOUSCOVERAGETYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractContinuousCoverageType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return ABSTRACTCOVERAGETYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        COVERAGEFUNCTIONTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","coverageFunction"),
                        0, 1, false, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractCoordinateOperationType"&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:IdentifiedObjectType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element minOccurs="0" ref="gml:domainOfValidity"/&gt;
     *                  &lt;element maxOccurs="unbounded" ref="gml:scope"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:operationVersion"/&gt;
     *                  &lt;element maxOccurs="unbounded" minOccurs="0" ref="gml:coordinateOperationAccuracy"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:sourceCRS"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:targetCRS"/&gt;
     *              &lt;/sequence&gt;
     *          &lt;/extension&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTCOORDINATEOPERATIONTYPE_TYPE = build_ABSTRACTCOORDINATEOPERATIONTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTCOORDINATEOPERATIONTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractCoordinateOperationType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return IDENTIFIEDOBJECTTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        _DOMAINOFVALIDITY_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","domainOfValidity"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.STRING_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","scope"),
                        1, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.STRING_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","operationVersion"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        _COORDINATEOPERATIONACCURACY_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","coordinateOperationAccuracy"),
                        0, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        CRSPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","sourceCRS"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        CRSPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","targetCRS"),
                        0, 1, false, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractCoordinateSystemType"&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:IdentifiedObjectType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element maxOccurs="unbounded" ref="gml:axis"/&gt;
     *              &lt;/sequence&gt;
     *              &lt;attributeGroup ref="gml:AggregationAttributeGroup"/&gt;
     *          &lt;/extension&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTCOORDINATESYSTEMTYPE_TYPE = build_ABSTRACTCOORDINATESYSTEMTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTCOORDINATESYSTEMTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractCoordinateSystemType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return IDENTIFIEDOBJECTTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        COORDINATESYSTEMAXISPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","axis"),
                        1, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        AGGREGATIONTYPE_TYPE,
                        new NameImpl("aggregationType"),
                        0, 1, true, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractCoverageType"&gt;
     *      &lt;annotation&gt;
     *          &lt;documentation&gt;The base type for coverages is gml:AbstractCoverageType. The basic elements of a coverage can be seen in this content model: the coverage contains gml:domainSet and gml:rangeSet properties. The gml:domainSet property describes the domain of the coverage and the gml:rangeSet property describes the range of the coverage.&lt;/documentation&gt;
     *      &lt;/annotation&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:AbstractFeatureType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element ref="gml:domainSet"/&gt;
     *                  &lt;element ref="gml:rangeSet"/&gt;
     *              &lt;/sequence&gt;
     *          &lt;/extension&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTCOVERAGETYPE_TYPE = build_ABSTRACTCOVERAGETYPE_TYPE();
    
    private static ComplexType build_ABSTRACTCOVERAGETYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractCoverageType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return ABSTRACTFEATURETYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        DOMAINSETTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","domainSet"),
                        1, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        RANGESETTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","rangeSet"),
                        1, 1, false, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractCurveSegmentType"&gt;
     *      &lt;attribute default="0" name="numDerivativesAtStart" type="integer"/&gt;
     *      &lt;attribute default="0" name="numDerivativesAtEnd" type="integer"/&gt;
     *      &lt;attribute default="0" name="numDerivativeInterior" type="integer"/&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTCURVESEGMENTTYPE_TYPE = build_ABSTRACTCURVESEGMENTTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTCURVESEGMENTTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractCurveSegmentType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return XSSchema.ANYTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.INTEGER_TYPE,
                        new NameImpl("numDerivativesAtStart"),
                        0, 1, true, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.INTEGER_TYPE,
                        new NameImpl("numDerivativesAtEnd"),
                        0, 1, true, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.INTEGER_TYPE,
                        new NameImpl("numDerivativeInterior"),
                        0, 1, true, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractCurveType"&gt;
     *      &lt;annotation&gt;
     *          &lt;documentation&gt;gml:AbstractCurveType is an abstraction of a curve to support the different levels of complexity. The curve may always be viewed as a geometric primitive, i.e. is continuous.&lt;/documentation&gt;
     *      &lt;/annotation&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:AbstractGeometricPrimitiveType"/&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTCURVETYPE_TYPE = build_ABSTRACTCURVETYPE_TYPE();
    
    private static ComplexType build_ABSTRACTCURVETYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractCurveType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return ABSTRACTGEOMETRICPRIMITIVETYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                return null;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractDatumType"&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:IdentifiedObjectType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element minOccurs="0" ref="gml:domainOfValidity"/&gt;
     *                  &lt;element maxOccurs="unbounded" ref="gml:scope"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:anchorDefinition"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:realizationEpoch"/&gt;
     *              &lt;/sequence&gt;
     *          &lt;/extension&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTDATUMTYPE_TYPE = build_ABSTRACTDATUMTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTDATUMTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractDatumType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return IDENTIFIEDOBJECTTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        _DOMAINOFVALIDITY_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","domainOfValidity"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.STRING_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","scope"),
                        1, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        CODETYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","anchorDefinition"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.DATE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","realizationEpoch"),
                        0, 1, false, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractFeatureCollectionType"&gt;
     *      &lt;annotation&gt;
     *          &lt;appinfo&gt;deprecated&lt;/appinfo&gt;
     *      &lt;/annotation&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:AbstractFeatureType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element maxOccurs="unbounded" minOccurs="0" ref="gml:featureMember"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:featureMembers"/&gt;
     *              &lt;/sequence&gt;
     *          &lt;/extension&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTFEATURECOLLECTIONTYPE_TYPE = build_ABSTRACTFEATURECOLLECTIONTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTFEATURECOLLECTIONTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractFeatureCollectionType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return ABSTRACTFEATURETYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        FEATUREPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","featureMember"),
                        0, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        FEATUREARRAYPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","featureMembers"),
                        0, 1, false, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractFeatureMemberType"&gt;
     *      &lt;annotation&gt;
     *          &lt;documentation&gt;To create a collection of GML features, a property type shall be derived by extension from gml:AbstractFeatureMemberType.
     *  By default, this abstract property type does not imply any ownership of the features in the collection. The owns attribute of gml:OwnershipAttributeGroup may be used on a property element instance to assert ownership of a feature in the collection. A collection shall not own a feature already owned by another object.&lt;/documentation&gt;
     *      &lt;/annotation&gt;
     *      &lt;sequence/&gt;
     *      &lt;attributeGroup ref="gml:OwnershipAttributeGroup"/&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTFEATUREMEMBERTYPE_TYPE = build_ABSTRACTFEATUREMEMBERTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTFEATUREMEMBERTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractFeatureMemberType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return XSSchema.ANYTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.BOOLEAN_TYPE,
                        new NameImpl("owns"),
                        0, 1, true, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractFeatureType"&gt;
     *      &lt;annotation&gt;
     *          &lt;documentation&gt;The basic feature model is given by the gml:AbstractFeatureType.
     *  The content model for gml:AbstractFeatureType adds two specific properties suitable for geographic features to the content model defined in gml:AbstractGMLType. 
     *  The value of the gml:boundedBy property describes an envelope that encloses the entire feature instance, and is primarily useful for supporting rapid searching for features that occur in a particular location. 
     *  The value of the gml:location property describes the extent, position or relative location of the feature.&lt;/documentation&gt;
     *      &lt;/annotation&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:AbstractGMLType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element minOccurs="0" ref="gml:boundedBy"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:location"/&gt;
     *              &lt;/sequence&gt;
     *          &lt;/extension&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTFEATURETYPE_TYPE = build_ABSTRACTFEATURETYPE_TYPE();
    
    private static ComplexType build_ABSTRACTFEATURETYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractFeatureType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return ABSTRACTGMLTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        BOUNDINGSHAPETYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","boundedBy"),
                        0, 1, true, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        LOCATIONPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","location"),
                        0, 1, false, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractGMLType"&gt;
     *      &lt;sequence&gt;
     *          &lt;group ref="gml:StandardObjectProperties"/&gt;
     *      &lt;/sequence&gt;
     *      &lt;attribute ref="gml:id" use="required"/&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTGMLTYPE_TYPE = build_ABSTRACTGMLTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTGMLTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractGMLType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return XSSchema.ANYTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        METADATAPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","metaDataProperty"),
                        0, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        STRINGORREFTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","description"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        REFERENCETYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","descriptionReference"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        CODEWITHAUTHORITYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","identifier"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        CODETYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","name"),
                        0, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.ID_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","id"),
                        0, 1, true, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractGeneralConversionType"&gt;
     *      &lt;complexContent&gt;
     *          &lt;restriction base="gml:AbstractCoordinateOperationType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element maxOccurs="unbounded" minOccurs="0" ref="gml:metaDataProperty"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:description"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:descriptionReference"/&gt;
     *                  &lt;element ref="gml:identifier"/&gt;
     *                  &lt;element maxOccurs="unbounded" minOccurs="0" ref="gml:name"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:remarks"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:domainOfValidity"/&gt;
     *                  &lt;element maxOccurs="unbounded" ref="gml:scope"/&gt;
     *                  &lt;element maxOccurs="unbounded" minOccurs="0" ref="gml:coordinateOperationAccuracy"/&gt;
     *              &lt;/sequence&gt;
     *              &lt;attribute ref="gml:id" use="required"/&gt;
     *          &lt;/restriction&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTGENERALCONVERSIONTYPE_TYPE = build_ABSTRACTGENERALCONVERSIONTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTGENERALCONVERSIONTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractGeneralConversionType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return ABSTRACTCOORDINATEOPERATIONTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        METADATAPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","metaDataProperty"),
                        0, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        STRINGORREFTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","description"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        REFERENCETYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","descriptionReference"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        CODEWITHAUTHORITYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","identifier"),
                        1, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        CODETYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","name"),
                        0, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.STRING_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","remarks"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        _DOMAINOFVALIDITY_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","domainOfValidity"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.STRING_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","scope"),
                        1, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        _COORDINATEOPERATIONACCURACY_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","coordinateOperationAccuracy"),
                        0, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.ID_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","id"),
                        0, 1, true, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractGeneralDerivedCRSType"&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:AbstractCRSType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element ref="gml:conversion"/&gt;
     *              &lt;/sequence&gt;
     *          &lt;/extension&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTGENERALDERIVEDCRSTYPE_TYPE = build_ABSTRACTGENERALDERIVEDCRSTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTGENERALDERIVEDCRSTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractGeneralDerivedCRSType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return ABSTRACTCRSTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        GENERALCONVERSIONPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","conversion"),
                        1, 1, false, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType name="AbstractGeneralOperationParameterPropertyType"&gt;
     *      &lt;annotation&gt;
     *          &lt;documentation&gt;gml:AbstractGeneralOperationParameterPropertyType is a property type for association roles to an operation parameter or group, either referencing or containing the definition of that parameter or group.&lt;/documentation&gt;
     *      &lt;/annotation&gt;
     *      &lt;sequence minOccurs="0"&gt;
     *          &lt;element ref="gml:AbstractGeneralOperationParameter"/&gt;
     *      &lt;/sequence&gt;
     *      &lt;attributeGroup ref="gml:AssociationAttributeGroup"/&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTGENERALOPERATIONPARAMETERPROPERTYTYPE_TYPE = build_ABSTRACTGENERALOPERATIONPARAMETERPROPERTYTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTGENERALOPERATIONPARAMETERPROPERTYTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractGeneralOperationParameterPropertyType"),
                false, false, null, null) {
            @Override
            public AttributeType buildSuper() {
                return XSSchema.ANYTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        ABSTRACTGENERALOPERATIONPARAMETERTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","AbstractGeneralOperationParameter"),
                        1, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XLINKSchema._ACTUATE_TYPE,
                        new NameImpl("http://www.w3.org/1999/xlink","actuate"),
                        0, 1, true, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.ANYURI_TYPE,
                        new NameImpl("http://www.w3.org/1999/xlink","arcrole"),
                        0, 1, true, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.ANYURI_TYPE,
                        new NameImpl("http://www.w3.org/1999/xlink","href"),
                        0, 1, true, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        NILREASONTYPE_TYPE,
                        new NameImpl("nilReason"),
                        0, 1, true, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.ANYURI_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","remoteSchema"),
                        0, 1, true, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.ANYURI_TYPE,
                        new NameImpl("http://www.w3.org/1999/xlink","role"),
                        0, 1, true, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XLINKSchema._SHOW_TYPE,
                        new NameImpl("http://www.w3.org/1999/xlink","show"),
                        0, 1, true, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.STRING_TYPE,
                        new NameImpl("http://www.w3.org/1999/xlink","title"),
                        0, 1, true, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.STRING_TYPE,
                        new NameImpl("http://www.w3.org/1999/xlink","type"),
                        0, 1, true, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractGeneralOperationParameterType"&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:IdentifiedObjectType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element minOccurs="0" ref="gml:minimumOccurs"/&gt;
     *              &lt;/sequence&gt;
     *          &lt;/extension&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTGENERALOPERATIONPARAMETERTYPE_TYPE = build_ABSTRACTGENERALOPERATIONPARAMETERTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTGENERALOPERATIONPARAMETERTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractGeneralOperationParameterType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return IDENTIFIEDOBJECTTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.NONNEGATIVEINTEGER_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","minimumOccurs"),
                        0, 1, false, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType name="AbstractGeneralParameterValuePropertyType"&gt;
     *      &lt;annotation&gt;
     *          &lt;documentation&gt;gml:AbstractGeneralParameterValuePropertyType is a  property type for inline association roles to a parameter value or group of parameter values, always containing the values.&lt;/documentation&gt;
     *      &lt;/annotation&gt;
     *      &lt;sequence&gt;
     *          &lt;element ref="gml:AbstractGeneralParameterValue"/&gt;
     *      &lt;/sequence&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTGENERALPARAMETERVALUEPROPERTYTYPE_TYPE = build_ABSTRACTGENERALPARAMETERVALUEPROPERTYTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTGENERALPARAMETERVALUEPROPERTYTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractGeneralParameterValuePropertyType"),
                false, false, null, null) {
            @Override
            public AttributeType buildSuper() {
                return XSSchema.ANYTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        ABSTRACTGENERALPARAMETERVALUETYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","AbstractGeneralParameterValue"),
                        1, 1, false, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractGeneralParameterValueType"&gt;
     *      &lt;sequence/&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTGENERALPARAMETERVALUETYPE_TYPE = build_ABSTRACTGENERALPARAMETERVALUETYPE_TYPE();
    
    private static ComplexType build_ABSTRACTGENERALPARAMETERVALUETYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractGeneralParameterValueType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return XSSchema.ANYTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                return null;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractGeneralTransformationType"&gt;
     *      &lt;complexContent&gt;
     *          &lt;restriction base="gml:AbstractCoordinateOperationType"&gt;
     *              &lt;sequence&gt;
     *                  &lt;element maxOccurs="unbounded" minOccurs="0" ref="gml:metaDataProperty"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:description"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:descriptionReference"/&gt;
     *                  &lt;element ref="gml:identifier"/&gt;
     *                  &lt;element maxOccurs="unbounded" minOccurs="0" ref="gml:name"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:remarks"/&gt;
     *                  &lt;element minOccurs="0" ref="gml:domainOfValidity"/&gt;
     *                  &lt;element maxOccurs="unbounded" ref="gml:scope"/&gt;
     *                  &lt;element ref="gml:operationVersion"/&gt;
     *                  &lt;element maxOccurs="unbounded" minOccurs="0" ref="gml:coordinateOperationAccuracy"/&gt;
     *                  &lt;element ref="gml:sourceCRS"/&gt;
     *                  &lt;element ref="gml:targetCRS"/&gt;
     *              &lt;/sequence&gt;
     *              &lt;attribute ref="gml:id" use="required"/&gt;
     *          &lt;/restriction&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTGENERALTRANSFORMATIONTYPE_TYPE = build_ABSTRACTGENERALTRANSFORMATIONTYPE_TYPE();
    
    private static ComplexType build_ABSTRACTGENERALTRANSFORMATIONTYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractGeneralTransformationType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return ABSTRACTCOORDINATEOPERATIONTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        METADATAPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","metaDataProperty"),
                        0, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        STRINGORREFTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","description"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        REFERENCETYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","descriptionReference"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        CODEWITHAUTHORITYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","identifier"),
                        1, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        CODETYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","name"),
                        0, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.STRING_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","remarks"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        _DOMAINOFVALIDITY_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","domainOfValidity"),
                        0, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.STRING_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","scope"),
                        1, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.STRING_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","operationVersion"),
                        1, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        _COORDINATEOPERATIONACCURACY_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","coordinateOperationAccuracy"),
                        0, 2147483647, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        CRSPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","sourceCRS"),
                        1, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        CRSPROPERTYTYPE_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","targetCRS"),
                        1, 1, false, null));
                descriptors.add(
                    new AttributeDescriptorImpl(
                        XSSchema.ID_TYPE,
                        new NameImpl("http://www.opengis.net/gml/3.2","id"),
                        0, 1, true, null));
                return descriptors;
            }
        };
        return builtType;
    }

    /**
     * <p>
     *  <pre>
     *   <code>
     *  &lt;complexType abstract="true" name="AbstractGeometricAggregateType"&gt;
     *      &lt;complexContent&gt;
     *          &lt;extension base="gml:AbstractGeometryType"&gt;
     *              &lt;attributeGroup ref="gml:AggregationAttributeGroup"/&gt;
     *          &lt;/extension&gt;
     *      &lt;/complexContent&gt;
     *  &lt;/complexType&gt;
     *
     *    </code>
     *   </pre>
     * </p>
     *
     * @generated
     */
    public static final ComplexType ABSTRACTGEOMETRICAGGREGATETYPE_TYPE = build_ABSTRACTGEOMETRICAGGREGATETYPE_TYPE();
    
    private static ComplexType build_ABSTRACTGEOMETRICAGGREGATETYPE_TYPE() {
        ComplexType builtType = new AbstractLazyComplexTypeImpl(
                new NameImpl("http://www.opengis.net/gml/3.2","AbstractGeometricAggregateType"),
                false, true, null, null) {
            @Override
            public AttributeType buildSuper() {
                return ABSTRACTGEOMETRYTYPE_TYPE;
            }
            @Override
            public Collection<PropertyDescriptor> buildDescriptors() {
                List<PropertyDescriptor> descriptors = new ArrayList<PropertyDescriptor>();
                descriptors.add(
                    new AttributeDescriptorImpl(
                        AGGREGATIONTYPE_TYPE,
                        new NameImpl("aggregationType"),
                        0, 1, true, nul