stuf-gemma/dist/_gml.d.ts

Generated typings for various StUF BG 3.10 messages

import * as xlink from './_1999_xlink';
/** Closeness of reported coordinate values to values accepted as or being true. */
export type AbsoluteExternalPositionalAccuracyType = AbstractPositionalAccuracyType & {
    /** A quantitative result defined by the evaluation procedure used, and identified by the measureDescription. */
    result: MeasureType;
};
/** A continuous coverage as defined in ISO 19123 is a coverage that can return different values for the same feature attribute at different direct positions within a single spatiotemporal object in its spatiotemporal domain */
export type AbstractContinuousCoverageType = AbstractCoverageType & {
    coverageFunction?: CoverageFunctionType;
};
/** Basic encoding for coordinate operation objects, simplifying and restricting the DefinitionType as needed. */
export type AbstractCoordinateOperationBaseType = DefinitionType & {
    /** Database handle for the object.  It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.  An external identifier for the object in the form of a URI may be constructed using standard XML and XPointer methods.  This is done by concatenating the URI for the document, a fragment separator, and the value of the id attribute. */
    id: string;
    /** The name by which this coordinate operation is identified. */
    coordinateOperationName: CodeType;
    /** Contains or refers to a metadata package that contains metadata properties. */
    metaDataProperty?: MetaDataPropertyType[];
};
/** A mathematical operation on coordinates that transforms or converts coordinates to another coordinate reference system. Many but not all coordinate operations (from CRS A to CRS B) also uniquely define the inverse operation (from CRS B to CRS A). In some cases, the operation method algorithm for the inverse operation is the same as for the forward algorithm, but the signs of some operation parameter values must be reversed. In other cases, different algorithms are required for the forward and inverse operations, but the same operation parameter values are used. If (some) entirely different parameter values are needed, a different coordinate operation shall be defined. */
export type AbstractCoordinateOperationType = AbstractCoordinateOperationBaseType & {
    _positionalAccuracy?: PositionalAccuracyProxyType[];
    /** An identification of a coordinate operation. */
    coordinateOperationID?: IdentifierType[];
    /** Version of the coordinate transformation (i.e., instantiation due to the stochastic nature of the parameters). Mandatory when describing a transformation, and should not be supplied for a conversion. */
    operationVersion?: string;
    /** Information about this object or code. Contains text or refers to external text. */
    remarks?: StringOrRefType;
    /** Description of domain of usage, or limitations of usage, for which this CRS object is valid. */
    scope?: string;
    /** Association to the source CRS (coordinate reference system) of this coordinate operation. */
    sourceCRS?: CRSRefType;
    /** Association to the target CRS (coordinate reference system) of this coordinate operation. For constraints on multiplicity of "sourceCRS" and "targetCRS", see UML model of Coordinate Operation package in OGC Abstract Specification topic 2. */
    targetCRS?: CRSRefType;
    /** Area or region in which this CRS object is valid. */
    validArea?: ExtentType;
};
/** Basic encoding for coordinate system objects, simplifying and restricting the DefinitionType as needed. */
export type AbstractCoordinateSystemBaseType = DefinitionType & {
    /** Database handle for the object.  It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.  An external identifier for the object in the form of a URI may be constructed using standard XML and XPointer methods.  This is done by concatenating the URI for the document, a fragment separator, and the value of the id attribute. */
    id: string;
    /** The name by which this coordinate system is identified. */
    csName: CodeType;
    /** Contains or refers to a metadata package that contains metadata properties. */
    metaDataProperty?: MetaDataPropertyType[];
};
/** A coordinate system (CS) is the set of coordinate system axes that spans a given coordinate space. A CS is derived from a set of (mathematical) rules for specifying how coordinates in a given space are to be assigned to points. The coordinate values in a coordinate tuple shall be recorded in the order in which the coordinate system axes associations are recorded, whenever those coordinates use a coordinate reference system that uses this coordinate system. This abstract complexType shall not be used, extended, or restricted, in an Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document. */
export type AbstractCoordinateSystemType = AbstractCoordinateSystemBaseType & {
    /** An identification of a coordinate system. */
    csID?: IdentifierType[];
    /** Information about this object or code. Contains text or refers to external text. */
    remarks?: StringOrRefType;
    /** Association to a coordinate system axis. */
    usesAxis: CoordinateSystemAxisRefType[];
};
/** Abstract element which acts as the head of a substitution group for coverages. Note that a coverage is a GML feature. */
export type AbstractCoverageType = AbstractFeatureType & DomainSetProxyType & {
    dimension?: number;
    rangeSet: RangeSetType;
};
/** Curve segment defines a homogeneous segment of a curve. */
export type AbstractCurveSegmentType = {
    /** The attribute "numDerivativesInterior" specifies the type of continuity that is guaranteed interior to the curve. The default value of "0" means simple continuity, which is a mandatory minimum level of continuity. This level is referred to as "C 0 " in mathematical texts. A value of 1 means that the function and its first derivative are continuous at the appropriate end point: "C 1 " continuity. A value of "n" for any integer means the function and its first n derivatives are continuous: "C n " continuity.
     * NOTE: Use of these values is only appropriate when the basic curve definition is an underdetermined system. For example, line string segments cannot support continuity above C 0 , since there is no spare control parameter to adjust the incoming angle at the end points of the segment. Spline functions on the other hand often have extra degrees of freedom on end segments that allow them to adjust the values of the derivatives to support C 1 or higher continuity. */
    numDerivativeInterior?: number;
    /** The attribute "numDerivativesAtEnd" specifies the type of continuity between this curve segment and its successor. If this is the last curve segment in the curve, one of these values, as appropriate, is ignored. The default value of "0" means simple continuity, which is a mandatory minimum level of continuity. This level is referred to as "C 0 " in mathematical texts. A value of 1 means that the function and its first derivative are continuous at the appropriate end point: "C 1 " continuity. A value of "n" for any integer means the function and its first n derivatives are continuous: "C n " continuity.
     * NOTE: Use of these values is only appropriate when the basic curve definition is an underdetermined system. For example, line string segments cannot support continuity above C 0 , since there is no spare control parameter to adjust the incoming angle at the end points of the segment. Spline functions on the other hand often have extra degrees of freedom on end segments that allow them to adjust the values of the derivatives to support C 1 or higher continuity. */
    numDerivativesAtEnd?: number;
    /** The attribute "numDerivativesAtStart" specifies the type of continuity between this curve segment and its predecessor. If this is the first curve segment in the curve, one of these values, as appropriate, is ignored. The default value of "0" means simple continuity, which is a mandatory minimum level of continuity. This level is referred to as "C 0 " in mathematical texts. A value of 1 means that the function and its first derivative are continuous at the appropriate end point: "C 1 " continuity. A value of "n" for any integer means the function and its first n derivatives are continuous: "C n " continuity.
     * NOTE: Use of these values is only appropriate when the basic curve definition is an underdetermined system. For example, line string segments cannot support continuity above C 0 , since there is no spare control parameter to adjust the incoming angle at the end points of the segment. Spline functions on the other hand often have extra degrees of freedom on end segments that allow them to adjust the values of the derivatives to support C 1 or higher continuity. */
    numDerivativesAtStart?: number;
};
/** An abstraction of a curve to support the different levels of complexity. The curve can always be viewed as a geometric
 * primitive, i.e. is continuous. */
export type AbstractCurveType = AbstractGeometricPrimitiveType & {};
/** Basic encoding for datum objects, simplifying and restricting the DefinitionType as needed. */
export type AbstractDatumBaseType = DefinitionType & {
    /** Database handle for the object.  It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.  An external identifier for the object in the form of a URI may be constructed using standard XML and XPointer methods.  This is done by concatenating the URI for the document, a fragment separator, and the value of the id attribute. */
    id: string;
    /** The name by which this datum is identified. */
    datumName: CodeType;
    /** Contains or refers to a metadata package that contains metadata properties. */
    metaDataProperty?: MetaDataPropertyType[];
};
/** A datum specifies the relationship of a coordinate system to the earth, thus creating a coordinate reference system. A datum uses a parameter or set of parameters that determine the location of the origin of the coordinate reference system. Each datum subtype can be associated with only specific types of coordinate systems. This abstract complexType shall not be used, extended, or restricted, in an Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document. */
export type AbstractDatumType = AbstractDatumBaseType & {
    /** Description, possibly including coordinates, of the point or points used to anchor the datum to the Earth. Also known as the "origin", especially for engineering and image datums. The codeSpace attribute can be used to reference a source of more detailed on this point or surface, or on a set of such descriptions.
     * - For a geodetic datum, this point is also known as the fundamental point, which is traditionally the point where the relationship between geoid and ellipsoid is defined. In some cases, the "fundamental point" may consist of a number of points. In those cases, the parameters defining the geoid/ellipsoid relationship have been averaged for these points, and the averages adopted as the datum definition.
     * - For an engineering datum, the anchor point may be a physical point, or it may be a point with defined coordinates in another CRS. When appropriate, the coordinates of this anchor point can be referenced in another document, such as referencing a GML feature that references or includes a point position.
     * - For an image datum, the anchor point is usually either the centre of the image or the corner of the image.
     * - For a temporal datum, this attribute is not defined. Instead of the anchor point, a temporal datum carries a separate time origin of type DateTime. */
    anchorPoint?: CodeType;
    /** An identification of a datum. */
    datumID?: IdentifierType[];
    /** The time after which this datum definition is valid. This time may be precise (e.g. 1997.0 for IRTF97) or merely a year (e.g. 1983 for NAD83). In the latter case, the epoch usually refers to the year in which a major recalculation of the geodetic control network, underlying the datum, was executed or initiated. An old datum can remain valid after a new datum is defined. Alternatively, a datum may be superseded by a later datum, in which case the realization epoch for the new datum defines the upper limit for the validity of the superseded datum. */
    realizationEpoch?: Date;
    /** Information about this object or code. Contains text or refers to external text. */
    remarks?: StringOrRefType;
    /** Description of domain of usage, or limitations of usage, for which this CRS object is valid. */
    scope?: string;
    /** Area or region in which this CRS object is valid. */
    validArea?: ExtentType;
};
/** A discrete coverage consists of a domain set, range set and optionally a coverage function. The domain set consists of either geometry or temporal objects, finite in number. The range set is comprised of a finite number of attribute values each of which is associated to every direct position within any single spatiotemporal object in the domain. In other words, the range values are constant on each spatiotemporal object in the domain. This coverage function maps each element from the coverage domain to an element in its range. This definition conforms to ISO 19123. */
export type AbstractDiscreteCoverageType = AbstractCoverageType & {
    coverageFunction?: CoverageFunctionType;
};
/** A feature collection contains zero or more features. */
export type AbstractFeatureCollectionType = AbstractFeatureType & {
    featureMember?: FeaturePropertyType[];
    featureMembers?: FeatureArrayPropertyType;
};
/** An abstract feature provides a set of common properties, including id, metaDataProperty, name and description inherited from AbstractGMLType, plus boundedBy.    A concrete feature type must derive from this type and specify additional  properties in an application schema. A feature must possess an identifying attribute ('id' - 'fid' has been deprecated). */
export type AbstractFeatureType = AbstractGMLType & LocationProxyType & {
    boundedBy?: BoundingShapeType;
};
/** An abstract operation on coordinates that does not include any change of datum. The best-known example of a coordinate conversion is a map projection. The parameters describing coordinate conversions are defined rather than empirically derived. Note that some conversions have no parameters.
 *
 * This abstract complexType is expected to be extended for well-known operation methods with many Conversion instances, in Application Schemas that define operation-method-specialized element names and contents. This conversion uses an operation method, usually with associated parameter values. However, operation methods and parameter values are directly associated with concrete subtypes, not with this abstract type. All concrete types derived from this type shall extend this type to include a "usesMethod" element that references the "OperationMethod" element. Similarly, all concrete types derived from this type shall extend this type to include zero or more elements each named "uses...Value" that each use the type of an element substitutable for the "_generalParameterValue" element. */
export type AbstractGeneralConversionType = AbstractCoordinateOperationType & {
    /** Database handle for the object.  It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.  An external identifier for the object in the form of a URI may be constructed using standard XML and XPointer methods.  This is done by concatenating the URI for the document, a fragment separator, and the value of the id attribute. */
    id: string;
    _positionalAccuracy?: PositionalAccuracyProxyType[];
    /** An identification of a coordinate operation. */
    coordinateOperationID?: IdentifierType[];
    /** The name by which this coordinate operation is identified. */
    coordinateOperationName: CodeType;
    /** Contains or refers to a metadata package that contains metadata properties. */
    metaDataProperty?: MetaDataPropertyType[];
    /** Information about this object or code. Contains text or refers to external text. */
    remarks?: StringOrRefType;
    /** Description of domain of usage, or limitations of usage, for which this CRS object is valid. */
    scope?: string;
    /** Area or region in which this CRS object is valid. */
    validArea?: ExtentType;
};
/** A coordinate reference system that is defined by its coordinate conversion from another coordinate reference system (not by a datum). This abstract complexType shall not be used, extended, or restricted, in an Application Schema, to define a concrete subtype with a meaning equivalent to a concrete subtype specified in this document. */
export type AbstractGeneralDerivedCRSType = AbstractReferenceSystemType & {
    /** Association to the coordinate reference system used by this derived CRS. */
    baseCRS: CoordinateReferenceSystemRefType;
    /** Association to the coordinate conversion used to define this derived CRS. */
    definedByConversion: GeneralConversionRefType;
};
/** Association to an operation parameter or group, either referencing or containing the definition of that parameter or group. */
export type AbstractGeneralOperationParameterRefType = GeneralOperationParameterProxyType & {
    /** Reference to an XML Schema fragment that specifies the content model of the propertys value. This is in conformance with the XML Schema Section 4.14 Referencing Schemas from Elsewhere. */
    remoteSchema?: string;
    actuate: xlink.actuateType;
    arcrole: string;
    href: string;
    role: string;
    show: xlink.showType;
    title: string;
    type: xlink.typeType;
};
/** Abstract definition of a parameter or group of parameters used by an operation method. */
export type AbstractGeneralOperationParameterType = DefinitionType & {
    /** The minimum number of times that values for this parameter group or parameter are required. If this attribute is omitted, the minimum number is one. */
    minimumOccurs?: number;
};
/** Abstract parameter value or group of parameter values.
 *
 * This abstract complexType is expected to be extended and restricted for well-known operation methods with many instances, in Application Schemas that define operation-method-specialized element names and contents. Specific parameter value elements are directly contained in concrete subtypes, not in this abstract type. All concrete types derived from this type shall extend this type to include one "...Value" element with an appropriate type, which should be one of the element types allowed in the ParameterValueType. In addition, all derived concrete types shall extend this type to include a "valueOfParameter" element that references one element substitutable for the "OperationParameter" element. */
export type AbstractGeneralParameterValueType = {};
/** An abstract operation on coordinates that usually includes a change of Datum. The parameters of a coordinate transformation are empirically derived from data containing the coordinates of a series of points in both coordinate reference systems. This computational process is usually "over-determined", allowing derivation of error (or accuracy) estimates for the transformation. Also, the stochastic nature of the parameters may result in multiple (different) versions of the same coordinate transformation.
 *
 * This abstract complexType is expected to be extended for well-known operation methods with many Transformation instances, in Application Schemas that define operation-method-specialized value element names and contents. This transformation uses an operation method with associated parameter values. However, operation methods and parameter values are directly associated with concrete subtypes, not with this abstract type. All concrete types derived from this type shall extend this type to include a "usesMethod" element that references one "OperationMethod" element. Similarly, all concrete types derived from this type shall extend this type to include one or more elements each named "uses...Value" that each use the type of an element substitutable for the "_generalParameterValue" element. */
export type AbstractGeneralTransformationType = AbstractCoordinateOperationType & {
    /** Database handle for the object.  It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.  An external identifier for the object in the form of a URI may be constructed using standard XML and XPointer methods.  This is done by concatenating the URI for the document, a fragment separator, and the value of the id attribute. */
    id: string;
    _positionalAccuracy?: PositionalAccuracyProxyType[];
    /** An identification of a coordinate operation. */
    coordinateOperationID?: IdentifierType[];
    /** The name by which this coordinate operation is identified. */
    coordinateOperationName: CodeType;
    /** Contains or refers to a metadata package that contains metadata properties. */
    metaDataProperty?: MetaDataPropertyType[];
    /** Version of the coordinate transformation (i.e., instantiation due to the stochastic nature of the parameters). Mandatory when describing a transformation, and should not be supplied for a conversion. */
    operationVersion: string;
    /** Information about this object or code. Contains text or refers to external text. */
    remarks?: StringOrRefType;
    /** Description of domain of usage, or limitations of usage, for which this CRS object is valid. */
    scope?: string;
    /** Association to the source CRS (coordinate reference system) of this coordinate operation. */
    sourceCRS: CRSRefType;
    /** Association to the target CRS (coordinate reference system) of this coordinate operation. For constraints on multiplicity of "sourceCRS" and "targetCRS", see UML model of Coordinate Operation package in OGC Abstract Specification topic 2. */
    targetCRS: CRSRefType;
    /** Area or region in which this CRS object is valid. */
    validArea?: ExtentType;
};
/** This is the abstract root type of the geometric aggregates. */
export type AbstractGeometricAggregateType = AbstractGeometryType & {};
/** This is the abstract root type of the geometric primitives. A geometric primitive is a geometric object that is not
 * decomposed further into other primitives in the system. All primitives are oriented in the direction implied by the sequence of their
 * coordinate tuples. */
export type AbstractGeometricPrimitiveType = AbstractGeometryType & {};
/** All geometry elements are derived directly or indirectly from this abstract supertype. A geometry element may
 * have an identifying attribute ("gml:id"), a name (attribute "name") and a description (attribute "description"). It may be associated
 * with a spatial reference system (attribute "srsName"). The following rules shall be adhered: - Every geometry type shall derive
 * from this abstract type. - Every geometry element (i.e. an element of a geometry type) shall be directly or indirectly in the
 * substitution group of _Geometry. */
export type AbstractGeometryType = AbstractGMLType & {
    /** Ordered list of labels for all the axes of this CRS. The gml:axisAbbrev value should be used for these axis
     * labels, after spaces and forbiddden characters are removed. When the srsName attribute is included, this attribute is optional.
     * When the srsName attribute is omitted, this attribute shall also be omitted. */
    axisLabels?: NCNameList;
    /** This attribute is included for backward compatibility with GML 2 and is deprecated with GML 3.
     * This identifer is superceded by "gml:id" inherited from AbstractGMLType. The attribute "gid" should not be used
     * anymore and may be deleted in future versions of GML without further notice. */
    gid?: string;
    /** The "srsDimension" is the length of coordinate sequence (the number of entries in the list). This dimension is
     * specified by the coordinate reference system. When the srsName attribute is omitted, this attribute shall be omitted. */
    srsDimension?: number;
    /** In general this reference points to a CRS instance of gml:CoordinateReferenceSystemType
     * (see coordinateReferenceSystems.xsd). For well known references it is not required that the CRS description exists at the
     * location the URI points to. If no srsName attribute is given, the CRS must be specified as part of the larger context this
     * geometry element is part of, e.g. a geometric element like point, curve, etc. It is expected that this attribute will be specified
     * at the direct position level only in rare cases. */
    srsName?: string;
    /** Ordered list of unit of measure (uom) labels for all the axes of this CRS. The value of the string in the
     * gml:catalogSymbol should be used for this uom labels, after spaces and forbiddden characters are removed. When the
     * axisLabels attribute is included, this attribute shall also be included. When the axisLabels attribute is omitted, this attribute
     * shall also be omitted. */
    uomLabels?: NCNameList;
};
/** All complexContent GML elements are directly or indirectly derived from this abstract supertype
 * to establish a hierarchy of GML types that may be distinguished from other XML types by their ancestry.
 * Elements in this hierarchy may have an ID and are thus referenceable. */
export type AbstractGMLType = {
    /** Database handle for the object.  It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.  An external identifier for the object in the form of a URI may be constructed using standard XML and XPointer methods.  This is done by concatenating the URI for the document, a fragment separator, and the value of the id attribute. */
    id?: string;
    /** Contains a simple text description of the object, or refers to an external description. */
    description?: StringOrRefType;
    /** Contains or refers to a metadata package that contains metadata properties. */
    metaDataProperty?: MetaDataPropertyType[];
    /** Label for the object, normally a descriptive name. An object may have several names, typically assigned by different authorities.  The authority for a name is indicated by the value of its (optional) codeSpace attribute.  The name may or may not be unique, as determined by the rules of the organization responsible for the codeSpace. */
    name?: NameProxyType[];
};
/** A gridded surface is a parametric curve
 * surface derived from a rectangular grid in the parameter
 * space. The rows from this grid are control points for
 * horizontal surface curves; the columns are control points
 * for vertical surface curves. The working assumption is that
 * for a pair of parametric co-ordinates (s, t) that the
 * horizontal curves for each integer offset are calculated
 * and evaluated at "s". The defines a sequence of control
 * points:
 *
 * cn(s) : s  1 .....columns
 *
 * From this sequence a vertical curve is calculated for "s",
 * and evaluated at "t". In most cases, the order of
 * calculation (horizontal-vertical vs. vertical-horizontal)
 * does not make a difference. Where it does, the horizontal-
 * vertical order shall be the one used.
 *
 * Logically, any pair of curve interpolation types can lead
 * to a subtype of GriddedSurface. The following clauses
 * define some most commonly encountered surfaces that can
 * be represented in this manner. */
export type AbstractGriddedSurfaceType = AbstractParametricCurveSurfaceType & {
    /** The attribute columns gives the number
     * of columns in the parameter grid. */
    columns?: number;
    row: RowType[];
    /** The attribute rows gives the number
     * of rows in the parameter grid. */
    rows?: number;
};
/** An abstract base type for complex metadata types. */
export type AbstractMetaDataType = {
    /** Database handle for the object.  It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.  An external identifier for the object in the form of a URI may be constructed using standard XML and XPointer methods.  This is done by concatenating the URI for the document, a fragment separator, and the value of the id attribute. */
    id?: string;
};
export type AbstractParametricCurveSurfaceType = AbstractSurfacePatchType & {};
/** Position error estimate (or accuracy) data. */
export type AbstractPositionalAccuracyType = {
    /** A description of the position accuracy parameter(s) provided. */
    measureDescription?: CodeType;
};
/** Basic encoding for reference system objects, simplifying and restricting the DefinitionType as needed. */
export type AbstractReferenceSystemBaseType = DefinitionType & {
    /** Database handle for the object.  It is of XML type ID, so is constrained to be unique in the XML document within which it occurs.  An external identifier for the object in the form of a URI may be constructed using standard XML and XPointer methods.  This is done by concatenating the URI for the document, a fragment separator, and the value of the id attribute. */
    id: string;
    /** Contains or refers to a metadata package that contains metadata properties. */
    metaDataProperty?: MetaDataPropertyType[];
    /** The name by which this reference system is identified. */
    srsName: CodeType;
};
/** Description of a spatial and/or temporal reference system used by a dataset. */
export type AbstractReferenceSystemType = AbstractReferenceSystemBaseType & {
    /** Information about this object or code. Contains text or refers to external text. */
    remarks?: StringOrRefType;
    /** Description of domain of usage, or limitations of usage, for which this CRS object is valid. */
    scope?: string;
    /** An identification of a reference system. */
    srsID?: IdentifierType[];
    /** Area or region in which this CRS object is valid. */
    validArea?: ExtentType;
};
/** Encapsulates a ring to represent the surface boundary property of a surface. */
export type AbstractRingPropertyType = RingProxyType & {};
/** An abstraction of a ring to support surface boundaries of different complexity. */
export type AbstractRingType = AbstractGeometryType & {};
/** An abstraction of a solid to support the different levels of complexity. A solid is always contiguous. */
export type AbstractSolidType = AbstractGeometricPrimitiveType & {};
/** [complexType of] The value of the top-level property. It is an abstract element. Used as the head element of the substitution group for extensibility purposes. */
export type AbstractStyleType = AbstractGMLType & {};
/** A surface patch defines a homogenuous portion of a surface. */
export type AbstractSurfacePatchType = {};
/** An abstraction of a surface to support the different levels of complexity. A surface is always a continuous region of a plane. */
export type AbstractSurfaceType = AbstractGeometricPrimitiveType & {};
/** The abstract supertype for temporal complexes. */
export type AbstractTimeComplexType = AbstractTimeObjectType & {};
/** The abstract supertype for temporal geometric primitives.
 * A temporal geometry must be associated with a temporal reference system via URI.
 * The Gregorian calendar with UTC is the default reference system, following ISO
 * 8601. Other reference systems in common use include the GPS calendar and the
 * Julian calendar. */
export type AbstractTimeGeometricPrimitiveType = AbstractTimePrimitiveType & {
    frame?: string;
};
/** The abstract supertype for temporal objects. */
export type AbstractTimeObjectType = AbstractGMLType & {};
/** The abstract supertype for temporal primitives. */
export type AbstractTimePrimitiveType = AbstractTimeObjectType & {
    relatedTime?: RelatedTimeType[];
};
/** A value in the time domain is measured relative to a temporal reference system. Common
 * types of reference systems include calendars, ordinal temporal reference systems, and
 * temporal coordinate systems (time elapsed since some epoch, e.g. UNIX time). */
export type AbstractTimeReferenceSystemType = DefinitionType & {
    domainOfValidity?: string;
};
/** A timeslice encapsulates the time-varying properties of a dynamic feature--it
 * must be extended to represent a timestamped projection of a feature. The dataSource
 * property describes how the temporal data was acquired. */
export type AbstractTimeSliceType = AbstractGMLType & {
    dataSource?: StringOrRefType;
    validTime: TimePrimitivePropertyType;
};
/** The element "complex" carries a reference to the complex containing this primitive. */
export type AbstractTimeTopologyPrimitiveType = AbstractTimePrimitiveType & {
    complex?: ReferenceType;
};
export type AbstractTopologyType = AbstractGMLType & {};
export type AbstractTopoPrimitiveType = AbstractTopologyType & {
    container?: ContainerPropertyType;
    isolated?: IsolatedPropertyType[];
};
/** Graph-specific styling property. */
export type AesheticCriteriaType = keyof typeof AesheticCriteriaType;
export declare const AesheticCriteriaType: Readonly<{
    MIN_CROSSINGS: "MIN_CROSSINGS";
    MIN_AREA: "MIN_AREA";
    MIN_BENDS: "MIN_BENDS";
    MAX_BENDS: "MAX_BENDS";
    UNIFORM_BENDS: "UNIFORM_BENDS";
    MIN_SLOPES: "MIN_SLOPES";
    MIN_EDGE_LENGTH: "MIN_EDGE_LENGTH";
    MAX_EDGE_LENGTH: "MAX_EDGE_LENGTH";
    UNIFORM_EDGE_LENGTH: "UNIFORM_EDGE_LENGTH";
    MAX_ANGULAR_RESOLUTION: "MAX_ANGULAR_RESOLUTION";
    MIN_ASPECT_RATIO: "MIN_ASPECT_RATIO";
    MAX_SYMMETRIES: "MAX_SYMMETRIES";
}>;
/** A placement takes a standard geometric
 * construction and places it in geographic space. It defines a
 * transformation from a constructive parameter space to the
 * co-ordinate space of the co-ordinate reference system being used.
 * Parameter spaces in formulae in this International Standard are
 * given as (u, v) in 2D and(u, v, w) in 3D. Co-ordinate reference
 * systems positions are given in formulae, in this International
 * Standard, by either (x, y) in 2D, or (x, y, z) in 3D.
 *
 * Affine placements are defined by linear transformations from
 * parameter space to the target co-ordiante space. 2-dimensional
 * Cartesian parameter space,(u,v) transforms into 3-dimensional co-
 * ordinate reference systems,(x,y,z) by using an affine
 * transformation,(u,v)->(x,y,z) which is defined :
 *
 * x	ux vx  	x0
 * u
 * y =	uy vy   + y0
 * v
 * x	uz vz	z0
 *
 * Then, given this equation, the location element of the
 * AffinePlacement is the direct position (x0, y0, z0), which is the
 * target position of the origin in (u, v). The two reference
 * directions (ux, uy, uz) and (vx, vy, vz) are the target
 * directions of the unit vectors at the origin in (u, v). */
export type AffinePlacementType = {
    /** Dimension of the constructive parameter
     * space. */
    inDimension: number;
    /** The location property gives
     * the target of the parameter space origin. This is the vector
     * (x0, y0, z0) in the formulae above. */
    location: DirectPositionType;
    /** Dimension of the co-ordinate space. */
    outDimension: number;
    /** The attribute refDirection gives the
     * target directions for the co-ordinate basis vectors of the
     * parameter space. These are the columns of the matrix in the
     * formulae given above. The number of directions given shall be
     * inDimension. The dimension of the directions shall be
     * outDimension. */
    refDirection: VectorType[];
};
/** Value of an angle quantity provided in either degree-minute-second format or single value format. */
export type AngleChoiceType = {
    angle: MeasureType;
    dmsAngle: DMSAngleType;
};
/** Value of an angle quantity recorded as a single number, with its units. Uses the MeasureType with the restriction that the unit of measure referenced by uom must be suitable for an angle, such as degrees or radians. */
export type AngleType = MeasureType & {};
/** An ArcByBulge is an arc string with only one arc unit, i.e. two control points and one bulge. */
export type ArcByBulgeType = ArcStringByBulgeType & {
    /** An arc is an arc string consiting of a single arc, the attribute is fixed to "1". */
    numArc?: number;
    /** The bulge controls the offset of each arc's midpoint. The "bulge" is the real number multiplier for the normal that determines the offset direction of the midpoint of each arc. The length of the bulge sequence is exactly 1 less than the length of the control point array, since a bulge is needed for each pair of adjacent points in the control point array. The bulge is not given by a distance, since it is simply a multiplier for the normal.
     * The midpoint of the resulting arc is given by: midPoint = ((startPoint + endPoint)/2.0) + bulge*normal */
    bulge: number[];
    /** Deprecated with GML version 3.1.0. */
    coordinates: CoordinatesType;
    /** The attribute "normal" is a vector normal (perpendicular) to the chord of the arc, the line joining the first and last
     * point of the arc. In a 2D coordinate system, there are only two possible directions for the normal, and it is often given as a signed real, indicating its length, with a positive sign indicating a left turn angle from the chord line, and a negative sign indicating a right turn from the chord. In 3D, the normal determines the plane of the arc, along with the start and endPoint of the arc.
     * The normal is usually a unit vector, but this is not absolutely necessary. If the normal is a zero vector, the geometric object becomes equivalent to the straight line between the two end points. The length of the normal sequence is exactly the same as for the bulge sequence, 1 less than the control point sequence length. */
    normal: VectorType[];
    /** This property element either references a point via the XLink-attributes or contains the point element. pointProperty
     * is the predefined property which can be used by GML Application Schemas whenever a GML Feature has a property with a value that
     * is substitutable for Point. */
    pointProperty: PointPropertyType[];
    /** Deprecated with GML version 3.1.0. Use "pointProperty" instead. Included for backwards compatibility with GML 3.0.0. */
    pointRep: PointPropertyType[];
    pos: DirectPositionType[];
    posList: DirectPositionListType;
};
type ArcByCenterPointProxyType = {
    ArcByCenterPoint?: ArcByCenterPointType;
    CircleByCenterPoint?: CircleByCenterPointType;
};
/** This variant of the arc requires that the points on the arc have to be computed instead of storing the coordinates directly. The control point is the center point of the arc plus the radius and the bearing at start and end. This represenation can be used only in 2D. */
export type ArcByCenterPointType = AbstractCurveSegmentType & {
    /** The attribute "interpolation" specifies the curve interpolation mechanism used for this segment. This mechanism
     * uses the control points and control parameters to determine the position of this curve segment. For an ArcByCenterPoint the interpolation is fixed as "circularArcCenterPointWithRadius". */
    interpolation: CurveInterpolationType;
    /** Since this type describes always a single arc, the attribute is fixed to "1". */
    numArc: number;
    /** Deprecated with GML version 3.1.0. */
    coordinates: CoordinatesType;
    /** The bearing of the arc at the end. */
    endAngle?: AngleType;
    /** This property element either references a point via the XLink-attributes or contains the point element. pointProperty
     * is the predefined property which can be used by GML Application Schemas whenever a GML Feature has a property with a value that
     * is substitutable for Point. */
    pointProperty: PointPropertyType;
    /** Deprecated with GML version 3.1.0. Use "pointProperty" instead. Included for backwards compatibility with GML 3.0.0. */
    pointRep: PointPropertyType;
    pos: DirectPositionType;
    posList: DirectPositionListType;
    /** The radius of the arc. */
    radius: LengthType;
    /** The bearing of the arc at the start. */
    startAngle?: AngleType;
};
/** Integer number of arc-minutes in a degree-minute-second angular value. */
export type ArcMinutesType = number;
type ArcProxyType = {
    Arc?: ArcType;
    Circle?: CircleType;
};
/** Number of arc-seconds in a degree-minute-second angular value. */
export type ArcSecondsType = number;
type ArcStringByBulgeProxyType = {
    ArcStringByBulge?: ArcStringByBulgeType;
    ArcByBulge?: ArcByBulgeType;
};
/** This variant of the arc computes the mid points of the arcs instead of storing the coordinates directly. The control point sequence consists of the start and end points of each arc plus the bulge. */
export type ArcStringByBulgeType = AbstractCurveSegmentType & {
    /** The attribute "interpolation" specifies the curve interpolation mechanism used for this segment. This mechanism
     * uses the control points and control parameters to determine the position of this curve segment. For an ArcStringByBulge the interpolation is fixed as "circularArc2PointWithBulge". */
    interpolation: CurveInterpolationType;
    /** The number of arcs in the arc string can be explicitly stated in this attribute. The number of control points in the arc string must be numArc + 1. */
    numArc?: number;
    /** The bulge controls the offset of each arc's midpoint. The "bulge" is the real number multiplier for the normal that determines the offset direction of the midpoint of each arc. The length of the bulge sequence is exactly 1 less than the length of the control point array, since a bulge is needed for each pair of adjacent points in the control point array. The bulge is not given by a distance, since it is simply a multiplier for the normal.
     * The midpoint of the resulting arc is given by: midPoint = ((startPoint + endPoint)/2.0) + bulge*normal */
    bulge: number[];
    /** Deprecated with GML version 3.1.0. */
    coordinates: CoordinatesType;
    /** The attribute "normal" is a vector normal (perpendicular) to the chord of the arc, the line joining the first and last
     * point of the arc. In a 2D coordinate system, there are only two possible directions for the normal, and it is often given as a signed real, indicating its length, with a positive sign indicating a left turn angle from the chord line, and a negative sign indicating a right turn from the chord. In 3D, the normal determines the plane of the arc, along with the start and endPoint of the arc.
     * The normal is usually a unit vector, but this is not absolutely necessary. If the normal is a zero vector, the geometric object becomes equivalent to the straight line between the two end points. The length of the normal sequence is exactly the same as for the bulge sequence, 1 less than the control point sequence length. */
    normal: VectorType[];
    /** This property element either references a point via the XLink-attributes or contains the point element. pointProperty
     * is the predefined property which can be used by GML Application Schemas whenever a GML Feature has a property with a value that
     * is substitutable for Point. */
    pointProperty: PointPropertyType[];
    /** Deprecated with GML version 3.1.0. Use "pointProperty" instead. Included for backwards compatibility with GML 3.0.0. */
    pointRep: PointPropertyType[];
    pos: DirectPositionType[];
    posList: DirectPositionListType;
};
type ArcStringProxyType = ArcProxyType & {
    ArcString?: ArcStringType;
};
/** An ArcString is a curve segment that uses three-point circular arc interpolation. */
export type ArcStringType = AbstractCurveSegmentType & {
    /** The attribute "interpolation" specifies the curve interpolation mechanism used for this segment. This mechanism
     * uses the control points and control parameters to determine the position of this curve segment. For an ArcString the interpolation is fixed as "circularArc3Points". */
    interpolation: CurveInterpolationType;
    /** The number of arcs in the arc string can be explicitly stated in this attribute. The number of control points in the arc string must be 2 * numArc + 1. */
    numArc?: number;
    /** Deprecated with GML version 3.1.0. */
    coordinates: CoordinatesType;
    /** This property element either references a point via the XLink-attributes or contains the point element. pointProperty
     * is the predefined property which can be used by GML Application Schemas whenever a GML Feature has a property with a value that
     * is substitutable for Point. */
    pointProperty: PointPropertyType[];
    /** Deprecated with GML version 3.1.0. Use "pointProperty" instead. Included for backwards compatibility with GML 3.0.0. */
    pointRep: PointPropertyType[];
    pos: DirectPositionType[];
    posList: DirectPositionListType;
};
/** An Arc is an arc string with only one arc unit, i.e. three control points. */
export type ArcType = ArcStringType & {
    /** An arc is an arc string consiting of a single arc, the attribute is fixed to "1". */
    numArc?: number;
    /** Deprecated with GML version 3.1.0. */
    coordinates: CoordinatesType;
    /** This property element either references a point via the XLink-attributes or contains the point element. pointProperty
     * is the predefined property which can be used by GML Application Schemas whenever a GML Feature has a property with a value that
     * is substitutable for Point. */
    pointProperty: PointPropertyType[];
    /** Deprecated with GML version 3.1.0. Use "pointProperty" instead. Included for backwards compatibility with GML 3.0.0. */
    pointRep: PointPropertyType[];
    pos: DirectPositionType[];
    posList: DirectPositionListType;
};
/** Value of a spatial area quantity, with its units. Uses the MeasureType with the restriction that the unit of measure referenced by uom must be suitable for an area, such as square metres or square miles. */
export type AreaType = MeasureType & {};
/** A base for derived types used to specify complex types containing an array of objects, by unspecified UML association - either composition or aggregation.  An instance of this type contains elements representing Objects.
 *
 * Ideally this type would be derived by extension of AssociationType.
 * However, this leads to a non-deterministic content model, since both the base and the extension have minOccurs="0", and is thus prohibited in XML Schema. */
export type ArrayAssociationType = {
    /** This abstract element is the head of a substitutionGroup hierararchy which may contain either simpleContent or complexContent elements.  It is used to assert the model position of "class" elements declared in other GML schemas. */
    _Object?: ObjectProxyType[];
};
/** A non-abstract generic collection type that can be used as a document element for a homogeneous collection of any GML types - Geometries, Topologies, Features ... */
export type ArrayType = AbstractGMLType & {
    members?: ArrayAssociationType;
};
/** A pattern or base for derived types used to specify complex types corresponding to an  unspecified UML association - either composition or aggregation.  Restricts the cardinality of Objects contained in the association to a maximum of one.  An instance of this type can contain an element representing an Object, or serve as a pointer to a remote Object.
 *
 * Descendents of this type can be restricted in an application schema to
 * * allow only specified classes as valid participants in the aggregation
 * * allow only association by reference (i.e. empty the content model) or by value (i.e. remove the xlinks).
 *
 * When used for association by reference, the value of the gml:remoteSchema attribute can be used to locate a schema fragment that constrains the target instance.
 *
 * In many cases it is desirable to impose the constraint prohibiting the occurence of both reference and value in the same instance, as that would be ambiguous.  This is accomplished by adding a directive in the annotation element of the element declaration.  This directive can be in the form of normative prose, or can use a Schematron pattern to automatically constrain co-occurrence - see the declaration for _strictAssociation below.
 *
 * If co-occurence is not prohibited, then both a link and content may be present.  If this occurs in an instance, then the rule for interpretation is that the instance found by traversing the href provides the normative value of the property, and should be used when possible.  The value(s) included as content may be used if the remote instance cannot be resolved.  This may be considered to be a "cached" version of the value(s). */
export type AssociationType = ObjectProxyType & {
    /** Reference to an XML Schema fragment that specifies the content model of the propertys value. This is in conformance with the XML Schema Section 4.14 Referencing Schemas from Elsewhere. */
    remoteSchema?: string;
    actuate: xlink.actuateType;
    arcrole: string;
    href: string;
    role: string;
    show: xlink.showType;
    title: string;
    type: xlink.typeType;
};
/** A non-abstract generic collection type that can be used as a document element for a collection of any GML types - Geometries, Topologies, Features ...
 *
 * FeatureCollections may only contain Features.  GeometryCollections may only contain Geometrys.  Bags are less constrained  they must contain objects that are substitutable for gml:_Object.  This may mix several levels, including Features, Definitions, Dictionaries, Geometries etc.
 *
 * The content model would ideally be
 * member 0..*
 * members 0..1
 * member 0..*
 * for maximum flexibility in building a collection from both homogeneous and distinct components:
 * included "member" elements each contain a single Object
 * an includ