import { AkimaCurve3d } from "../bspline/AkimaCurve3d";
import { BezierCurve3d } from "../bspline/BezierCurve3d";
import { BezierCurve3dH } from "../bspline/BezierCurve3dH";
import { BSplineCurve3d } from "../bspline/BSplineCurve";
import { BSplineCurve3dH } from "../bspline/BSplineCurve3dH";
import { BSplineSurface3d, BSplineSurface3dH } from "../bspline/BSplineSurface";
import { InterpolationCurve3d as InterpolationCurve3d, InterpolationCurve3dProps } from "../bspline/InterpolationCurve3d";
import { Arc3d } from "../curve/Arc3d";
import { CoordinateXYZ } from "../curve/CoordinateXYZ";
import { BagOfCurves, CurveCollection } from "../curve/CurveCollection";
import { AnyGeometryQuery } from "../curve/GeometryQuery";
import { LineSegment3d } from "../curve/LineSegment3d";
import { LineString3d } from "../curve/LineString3d";
import { Loop } from "../curve/Loop";
import { ParityRegion } from "../curve/ParityRegion";
import { Path } from "../curve/Path";
import { PointString3d } from "../curve/PointString3d";
import { TransitionSpiral3d } from "../curve/spiral/TransitionSpiral3d";
import { UnionRegion } from "../curve/UnionRegion";
import { AngleProps, AngleSweepProps } from "../Geometry";
import { GeometryHandler } from "../geometry3d/GeometryHandler";
import { Point3d } from "../geometry3d/Point3dVector3d";
import { XYProps, XYZProps } from "../geometry3d/XYZProps";
import { YawPitchRollProps } from "../geometry3d/YawPitchRollAngles";
import { AuxChannelDataType, PolyfaceAuxData } from "../polyface/AuxData";
import { IndexedPolyface } from "../polyface/Polyface";
import { TaggedNumericData } from "../polyface/TaggedNumericData";
import { Box } from "../solid/Box";
import { Cone } from "../solid/Cone";
import { LinearSweep } from "../solid/LinearSweep";
import { RotationalSweep } from "../solid/RotationalSweep";
import { RuledSweep } from "../solid/RuledSweep";
import { Sphere } from "../solid/Sphere";
import { TorusPipe } from "../solid/TorusPipe";
/**
 * `IModelJson` namespace has classes for serializing and deserialization json objects
 * @public
 */
export declare namespace IModelJson {
    /**
     * Property rules for json objects that can be deserialized to various Curve and Solid objects
     * @public
     */
    interface GeometryProps extends CurvePrimitiveProps, SolidPrimitiveProps, CurveCollectionProps {
        /** `{indexedMesh:...}` */
        indexedMesh?: IndexedMeshProps;
        /** `{point:...}` */
        point?: XYZProps;
        /** `{bsurf:...}` */
        bsurf?: BSplineSurfaceProps;
        /** `{pointString:...}` */
        pointString?: XYZProps[];
    }
    /**
     * Property rules for json objects that can be deserialized to various CurvePrimitives
     * * Only one of these is allowed in each instance.
     * @public
     */
    interface CurvePrimitiveProps {
        /** `{lineSegment:...}` */
        lineSegment?: [XYZProps, XYZProps];
        /** `{lineString:...}` */
        lineString?: XYZProps[];
        /** `{bcurve:...}` */
        bcurve?: BcurveProps;
        /** `{transitionSpiral:...}` */
        transitionSpiral?: TransitionSpiralProps;
        /** `{arc:...}` */
        arc?: ArcByVectorProps | [XYZProps, XYZProps, XYZProps];
        /** `{interpolationCurve:...}~ */
        interpolationCurve?: InterpolationCurve3dProps;
    }
    /**
     * Property rules for json objects that can be deserialized to single point
     * @public
     */
    interface PointProps {
        /** `{point:...}` */
        point?: XYZProps;
    }
    /**
     * Property rules for json objects that can be deserialized to a BsplineSurface
     * See `BCurveProps` for discussion of knot and pole counts.
     * @public
     */
    interface BSplineSurfaceProps {
        /** polynomial order (one more than degree) in the u parameter direction */
        orderU: number;
        /** polynomial order (one more than degree) in the v parameter direction */
        orderV: number;
        /** Square grid of control points (aka poles) in row major order (row is along the u direction) */
        points: [[[number]]];
        /** Array of knots for the u direction bspline */
        uKnots: [number];
        /** Array of knots for the v direction bspline */
        vKnots: [number];
        /** optional flag for periodic data in the u parameter direction */
        closedU?: boolean;
        /** optional flag for periodic data in the v parameter direction */
        closedV?: boolean;
    }
    /**
     * Interface for a collection of curves, e.g. as used as a swept contour.
     * @public
     */
    interface CurveCollectionProps extends PlanarRegionProps {
        /** A sequence of curves joined head to tail. */
        path?: [CurvePrimitiveProps];
        /**
         * A collection of curves with no required structure or connections
         * @deprecated in 5.0 - will not be removed until after 2026-06-13. Instead use bagOfCurves, which has correct capitalization and type. The old name has never been persisted.
        */
        bagofCurves?: [CurveCollectionProps];
        /** A collection of curves with no required structure or connections. */
        bagOfCurves?: [CurveCollectionProps | CurvePrimitiveProps];
    }
    /**
     * Interface for a collection of curves that bound a planar region
     * @public
     */
    interface PlanarRegionProps {
        /** `{loop:...}`
         * * A sequence of curves which connect head to tail, with the final connecting back to the first
         */
        loop?: [CurvePrimitiveProps];
        /** `{parityRegion:...}`
         * * A collection of loops, with composite inside/outside determined by parity rules.
         * * (The single outer boundary with one or more holes is a parityRegion)
         */
        parityRegion?: [{
            loop: [CurvePrimitiveProps];
        }];
        /** `{unionRegion:...}`
         * * A collection of loops and parityRegions
         */
        unionRegion?: [PlanarRegionProps];
    }
    /**
     * Interface for solid primitives: box, sphere, cylinder, cone, torusPipe, linear sweep, rotational sweep, ruled sweep.
     * @public
     */
    interface SolidPrimitiveProps {
        /** `{cylinder:...}` */
        cylinder?: CylinderProps;
        /** `{box:...}` */
        box?: BoxProps;
        /** `{sphere:............}` */
        sphere?: SphereProps;
        /** `{cone:............}` */
        cone?: ConeProps;
        /** `{torusPipe:............}` */
        torusPipe?: TorusPipeProps;
        /** `{linearSweep:.........}` */
        linearSweep?: LinearSweepProps;
        /** `{rotationalSweep:...}` */
        rotationalSweep?: RotationalSweepProps;
        /** `{ruledSweep:...}` */
        ruledSweep?: RuledSweepProps;
    }
    /**
     * Ways to specify an object's local coordinate frame.
     * * Most objects that implement AxesProps specify their local coordinate frame by a right-handed
     * rotation matrix (`yawPitchRollAngles`, `xyVectors`, `zxVectors`).
     * * A general invertible matrix can be specified by `xyzVectors`.
     * * An object that implements AxesProps typically specifies only one variant, or none for Identity.
     * @public
     */
    interface AxesProps {
        /**
         * A rotation specified by yaw, pitch, roll angles.
         * * Cases where only one of these angles is nonzero are intuitive.
         * * Cases where more than one is nonzero have difficult interactions and order issues.
         * * See [[YawPitchRollAngles]] for further information.
         * @public
         */
        yawPitchRollAngles?: YawPitchRollProps;
        /**
         * A rotation specified by an array of two vectors [xAxis, yAxis].
         * * The first vector gives the local x-axis direction; the second determines the local xy-plane.
         * * A third implied axis is perpendicular to these.
         * * The implied rotation is `Matrix3d.createRigidFromColumns(xAxis, yAxis, AxisOrder.XYZ)`.
         */
        xyVectors?: [XYZProps, XYZProps];
        /**
         * A rotation specified by an array of two vectors [zAxis, xAxis].
         * * The first vector gives the local z-axis direction; the second determines the local zx-plane.
         * * A third implied axis is perpendicular to these.
         * * The implied rotation is `Matrix3d.createRigidFromColumns(zAxis, xAxis, AxisOrder.ZXY)`.
         */
        zxVectors?: [XYZProps, XYZProps];
        /**
         * A local coordinate system specified by an array of three vectors [xAxis, yAxis, zAxis].
         * * The vectors should have positive length and be linearly independent, but otherwise they are unrestricted.
         * * This allows skew coordinate systems, left-handed frames, and non-uniform scaling.
         * * The implied matrix is `Matrix3d.createColumns(xAxis, yAxis, zAxis)`.
         */
        xyzVectors?: [XYZProps, XYZProps, XYZProps];
    }
    /**
     * Interface for Arc3d value defined by center, vectorX, vectorY and sweepStartEnd.
     * @public
     */
    interface ArcByVectorProps {
        /** Arc center point */
        center: XYZProps;
        /** Vector from center to 0-degree point (commonly called major axis vector) */
        vectorX: XYZProps;
        /** Vector from center to 90-degree point (common called minor axis vector) */
        vectorY: XYZProps;
        /** Start and end angles in parameterization `X=C+cos(theta) * vectorX + sin(theta) * vectorY` */
        sweepStartEnd: AngleSweepProps;
    }
    /**
     * Interface for a [[Cone]], defined by two centers and radii.
     * * A Cone typically has circular sections perpendicular to the axis line between centers.
     * * The cross section xy-plane is specified by an [[IModelJson.AxesProps]]:
     *   * Typically this is an `xyVectors`.
     *   * Elliptical cross sections can be specified with `xyzVectors`, which admits skew vectors
     * and/or vectors of different lengths. Elliptical cross sections are scaled by radius.
     * @public
     */
    interface ConeProps extends AxesProps {
        /** Point on axis at center of start section. */
        start: XYZProps;
        /** Point on axis at center of end section. */
        end: XYZProps;
        /** Radius of the section at `start` if circular, or scale factor if elliptical. */
        startRadius?: number;
        /** Radius of the section at `end` if circular, or scale factor if elliptical. */
        endRadius?: number;
        /** Constant radius of all sections if circular, or scale factor if elliptical. */
        radius?: number;
        /**
         * Optional section x-axis.
         * @deprecated in 5.0 - will not be removed until after 2026-06-13. This property has never been written. Optional axes are specified by an AxesProps.
         */
        vectorX?: XYZProps;
        /**
         * Optional section y-axis.
         * @deprecated in 5.0 - will not be removed until after 2026-06-13. This property has never been written. Optional axes are specified by an AxesProps.
         */
        vectorY?: XYZProps;
        /** flag for circular end caps. */
        capped?: boolean;
    }
    /**
     * Interface for cylinder defined by a radius and axis start and end centers.
     * @public
     */
    interface CylinderProps {
        /** axis point at start */
        start: XYZProps;
        /** axis point at end */
        end: XYZProps;
        /** cylinder radius */
        radius: number;
        /** flag for circular end caps. */
        capped?: boolean;
    }
    /**
     * Interface for a linear sweep of a base curve or region.
     * @public
     */
    interface LinearSweepProps {
        /** The swept curve or region.  Any curve collection */
        contour: CurveCollectionProps;
        /** The sweep vector  */
        vector: XYZProps;
        /** flag for circular end caps. */
        capped?: boolean;
    }
    /**
     * Interface for a rotational sweep of a base curve or region around an axis.
     * @public
     */
    interface RotationalSweepProps {
        /** The swept curve or region.  Any curve collection */
        contour: CurveCollectionProps;
        /** any point on the axis of rotation. */
        center: XYZProps;
        /** The axis of rotation  */
        axis: XYZProps;
        /** sweep angle */
        sweepAngle: AngleProps;
        /** flag for circular end caps. */
        capped?: boolean;
    }
    /**
     * Interface for a surface with rule lines between corresponding curves on successive contours
     * @public
     */
    interface RuledSweepProps {
        /** An array of swept curves or regions. */
        contour: [CurveCollectionProps];
        /** Optional capping flag. */
        capped?: boolean;
    }
    /**
     * Interface for spiral
     * * Any 4 (but not 5) of the 5 values `[startBearing, endBearing, startRadius, endRadius, length]`
     *       may be defined.
     * * In radius data, zero radius indicates straight line (infinite radius)
     * * Note that the inherited AxesProps allows multiple ways to specify orientation of the placement..
     * @public
     */
    interface TransitionSpiralProps extends AxesProps {
        /** origin of the coordinate system. */
        origin: XYZProps;
        /** angle at departure from origin. */
        startBearing?: AngleProps;
        /** End bearing. */
        endBearing?: AngleProps;
        /** Radius at start  (0 for straight line) */
        startRadius?: number;
        /** Radius at end  (0 for straight line) */
        endRadius?: number;
        /** length along curve.
         */
        length?: number;
        /** Fractional part of active interval.
         * * There has been name confusion between native and typescript .... accept any variant ..
         * * native (July 2020) emits activeFractionInterval
         */
        activeFractionInterval?: number[];
        /** TransitionSpiral type.
         * * expected names are given in `IntegratedSpiralTypeName` and `DirectSpiralTypeName`
         */
        type?: string;
    }
    /**
     * Interface for bspline curve (aka bcurve)
     * @public
     */
    interface BcurveProps {
        /** control points */
        points: [XYZProps];
        /** knots. */
        knots: [number];
        /** order of polynomial
         * * The order is the number of basis functions that are in effect at any knot value.
         * * The order is the number of points that affect the curve at any knot value,
         *     i.e. the size of the "local support" set
         * * `order=2` is lines (degree 1)
         * * `order=3` is quadratic (degree 2)
         * * `order=4` is cubic (degree 3)
         * * The number of knots follows the convention "poles+order= knots".
         * * In this convention (for example), a clamped cubic with knots `[0,0,0,0, 1,2,3,4,4,4,4]`
         * has:
         * * * 4 (`order`) copies of the start and end knot (0 and 4) and
         * * * 3 interior knots
         * * Hence expect 7 poles.
         */
        order: number;
        /** optional flag for periodic data. */
        closed?: boolean;
    }
    /**
     * Interface for Box (or frustum with all rectangular sections parallel to primary xy section).
     * * Orientation may be given in any `AxesProps` way (`yawPitchRollAngles`, `xyVectors`, `zxVectors`).
     * * If `topX` or `topY` are omitted, each defaults to its `baseX` or `baseY` peer.
     * * If `topOrigin` is given, `height` is unused.
     * * If `topOrigin` is omitted and `height` is given, `topOrigin` is computed along the z axis at distance `height`.
     * * If both `topOrigin` and `height` are omitted, `height` defaults to `baseX`, and `topOrigin` is computed as above.
     * @public
     */
    interface BoxProps extends AxesProps {
        /** Origin of the box coordinate system  (required) */
        origin: XYZProps;
        /** A previous mismatch existed between native and TypeScript code: TypeScript used "origin" where native used "baseOrigin".
         * Now both native and TypeScript will output both and accept either, preferring "origin".
         * "baseOrigin" is undocumented in TypeScript; it should not be used.
         * @internal
         */
        baseOrigin?: XYZProps;
        /** base x size (required) */
        baseX: number;
        /** base y size.
         * * if omitted, baseX is used.
         */
        baseY?: number;
        /** top origin.
         * * This is NOT required to be on the z axis.
         * * If omitted, it is computed along the z axis at distance `height`.
         */
        topOrigin?: XYZProps;
        /** optional height. This is only used if `topOrigin` is omitted.
         * * If omitted, `baseX` is used.
        */
        height?: number;
        /** x size on top section.
         * * If omitted, `baseX` is used.
         */
        topX?: number;
        /** y size on top section.
         * * If omitted, `baseY` is used.
         */
        topY?: number;
        /** optional capping flag. */
        capped?: boolean;
    }
    /**
     * Interface for a [[Sphere]].
     * * Local coordinate frame is supplied by an [[IModelJson.AxesProps]]:
     *   * Typically this is a `zxVectors`.
     *   * Skew axes can be specified with `xyzVectors`, in which case any specified radii scale these axes;
     * all other AxesProps specify a right-handed orthonormal triad.
     * @public
     */
    interface SphereProps extends AxesProps {
        /** Center of the sphere coordinate system */
        center: XYZProps;
        /** primary radius */
        radius?: number;
        /** optional x radius */
        radiusX?: number;
        /** optional y radius */
        radiusY?: number;
        /** optional z radius */
        radiusZ?: number;
        /** optional sweep range for latitude.  Default latitude limits are [-90,90 ] degrees. */
        latitudeStartEnd?: AngleSweepProps;
        /** optional capping flag. If missing, implied false */
        capped?: boolean;
    }
    /**
     * Interface for TorusPipe data
     * * Orientation may be given in any `AxesProp`s way (yawPitchRoll, xyVectors, zxVectors)
     * * Both radii are required.
     * * axes are required
     * * Axis definition is
     * * xy plane contains the major circle
     * * x axis points from donut hole center to flow center at start of pipe.
     * * z axis points through the hole.
     * @public
     */
    interface TorusPipeProps extends AxesProps {
        /** Center of the full torus coordinate system. (donut hole center) */
        center: XYZProps;
        /** primary radius  (elbow radius) */
        majorRadius: number;
        /** pipe radius */
        minorRadius: number;
        /** sweep angle.
         * * if omitted, full 360 degree sweep.
         */
        sweepAngle?: AngleProps;
        /** optional capping flag. If missing, implied false */
        capped?: boolean;
    }
    /**
     * Interface for the analytical data in a channel at a single input value.
     * See `AuxChannelData` for further information.
     * @public
     */
    interface AuxChannelDataProps {
        /** The input value for this data. */
        input: number;
        /** The vertex values for this data. A single value per vertex for scalar and distance types and 3 values (x,y,z) for normal or vector channels. */
        values: number[];
    }
    /**
     * Interface for a channel of analytical mesh data.
     * See `AuxChannel` for further information.
     * @public
     */
    interface AuxChannelProps {
        /** An array of analytical data at one or more input values. */
        data: AuxChannelDataProps[];
        /** The type of data stored in this channel. */
        dataType: AuxChannelDataType;
        /** Optional channel name. */
        name?: string;
        /** Optional input name. */
        inputName?: string;
    }
    /**
     * Interface for analytical mesh data.
     * See `PolyfaceAuxData` for further information.
     * @public
    */
    interface AuxDataProps {
        /** Array with one or more channels of auxiliary data. */
        channels: AuxChannelProps[];
        /** Indices mapping channel data to the mesh facets (must be parallel to mesh indices). */
        indices: number[];
    }
    /**
     * Interface for extra data attached to an indexed mesh.
     * See `TaggedNumericData` for further information (e.g. value `tagA` and `tagB` values)
     * @public
     */
    interface TaggedNumericDataProps {
        /** integer tag identifying the meaning of this tag.  */
        tagA: number;
        /** Second integer tag.  */
        tagB: number;
        /** application specific integer data */
        intData?: number[];
        /** application specific doubles */
        doubleData?: number[];
    }
    /**
     * Interface for an indexed mesh.
     * * IMPORTANT: All indices are one-based.
     * * i.e. vertex index given as 11 appears at index 10 in the data array.
     * * This is to allow a negated index to mean "don't draw the following edge"
     * * Although negative indices are not allowed for normalIndex, colorIndex, or paramIndex, the "one based" style
     *     is used for them so that all indices within the indexedMesh json object are handled similarly.
     * * In all index arrays, a ZERO indicates "end of facet".
     * @public
     */
    interface IndexedMeshProps {
        /** vertex coordinates */
        point: [XYZProps];
        /** surface normals */
        normal?: [XYZProps];
        /** texture space (uv parameter) coordinates */
        param?: [XYProps];
        /** 32 bit color values */
        color?: [number];
        /** SIGNED ONE BASED ZERO TERMINATED array of point indices. */
        pointIndex: [number];
        /** ONE BASED ZERO TERMINATED array of param indices.  ZERO is terminator for single facet. */
        paramIndex?: [number];
        /** ONE BASED ZERO TERMINATED array of normal indices. ZERO is terminator for single facet. */
        normalIndex?: [number];
        /** ONE BASED ZERO TERMINATED array of color indices. ZERO is terminator for single facet. */
        colorIndex?: [number];
        /**
         * Optional fixed block size for indices.
         * If defined, each facet is represented by `numPerFace` 1-based indices, with appended zeroes if the facet has fewer edges.
         * If undefined, mesh indices are 1-based, 0-terminated, variable-sized face loops.
         */
        numPerFace?: number;
        /** Indicates if mesh closure is unknown (0 | undefined), open sheet (1), or closed solid (2). */
        expectedClosure?: number;
        /**
         * The [[PolyfaceData.twoSided]] flag.
         */
        twoSided?: boolean;
        /** Optional analytical data at the vertices of the mesh */
        auxData?: AuxDataProps;
        /** Optional array of tagged geometry (such as to request subdivision surface) */
        tags?: TaggedNumericDataProps;
        /**
         * Optional edge -> edgeMate map, parallel to the other index arrays.
         * * Each entry is a zero-based index, or -1 face loop terminator, or -2 to indicate "no edge mate".
         */
        edgeMateIndex?: [number];
    }
    /** parser services for "iModelJson" schema
     * * 1: create a reader with `new ImodelJsonReader`
     * * 2: parse json fragment to strongly typed geometry: `const g = reader.parse (fragment)`
     * @public
     */
    class Reader {
        constructor();
        private static parseVector3dProperty;
        private static parsePoint3dProperty;
        private static parseSegment1dProperty;
        private static parseNumberProperty;
        /**
         * @internal
         */
        static parseTaggedNumericProps(json: any): TaggedNumericData | undefined;
        private static parseNumberArrayProperty;
        private static parseAngleProperty;
        /**
         * @param defaultFunction function to call if needed to produce a default value
         */
        private static parseAngleSweepProps;
        private static parseBooleanProperty;
        private static loadContourArray;
        private static parseYawPitchRollAnglesToMatrix3d;
        private static parseStringProperty;
        private static parseAxesFromVectors;
        /**
         * Look for orientation data and convert to Matrix3d.
         * * Search order and interpretation:
         * * * xyzVectors - general matrix, axes preserved
         * * * yawPitchRollAngles - right-handed rotation via axial rotations
         * * * xyVectors - right-handed rotation, xy-plane specified, axes squared and normalized
         * * * zxVectors - right-handed rotation, zx-plane specified, axes squared and normalized
         * @param json [in] json source data
         * @param createDefaultIdentity [in] If true and no orientation is present, return an identity matrix.  If false and no orientation is present, return undefined.
         */
        private static parseOrientation;
        private static parseArcByVectorProps;
        private static parseArcBy3Points;
        private static parseArcObject;
        /** Parse point content (right side) `[1,2,3]` to a CoordinateXYZ object. */
        static parseCoordinate(data?: any): CoordinateXYZ | undefined;
        /** Parse `transitionSpiral` content (right side) to TransitionSpiral3d. */
        static parseTransitionSpiral(data?: TransitionSpiralProps): TransitionSpiral3d | undefined;
        /** Parse `bcurve` content to BSplineCurve3d or BSplineCurve3dH object. */
        static parseBcurve(data?: any): BSplineCurve3d | BSplineCurve3dH | undefined;
        /** Parse `interpolationCurve` content to an InterpolationCurve3d object. */
        static parseInterpolationCurve(data?: any): InterpolationCurve3d | undefined;
        /** Parse `akimaCurve` content to an Akima curve object. */
        static parseAkimaCurve3d(data?: any): AkimaCurve3d | undefined;
        /** Parse array of json objects to array of instances. */
        static parseArray(data?: any): any[] | undefined;
        /** parse polyface aux data content to PolyfaceAuxData instance */
        static parsePolyfaceAuxData(data?: any, numPerFace?: number): PolyfaceAuxData | undefined;
        /** parse indexed mesh content to an IndexedPolyface instance */
        static parseIndexedMesh(data?: any): IndexedPolyface | undefined;
        /** parse contents of a curve collection to a CurveCollection instance */
        static parseCurveCollectionMembers(result: CurveCollection, data?: any): CurveCollection | undefined;
        /** Parse content of `bsurf` to BSplineSurface3d or BSplineSurface3dH */
        static parseBsurf(data?: any): BSplineSurface3d | BSplineSurface3dH | undefined;
        /** Parse `cone` contents to `Cone` instance  */
        static parseConeProps(json?: ConeProps): Cone | undefined;
        /** Parse `cylinder` content to `Cone` instance */
        static parseCylinderProps(json?: CylinderProps): Cone | undefined;
        /** Parse line segment (array of 2 points) properties to `LineSegment3d` instance */
        private static parseLineSegmentProps;
        /** Parse linear sweep content to `LinearSweep` instance. */
        static parseLinearSweep(json?: any): LinearSweep | undefined;
        /** Parse rotational sweep contents to `RotationalSweep` instance */
        static parseRotationalSweep(json?: RotationalSweepProps): RotationalSweep | undefined;
        /** Parse box contents to `Box` instance */
        static parseBox(json?: BoxProps): Box | undefined;
        /** Parse `SphereProps` to `Sphere` instance. */
        static parseSphere(json?: SphereProps): Sphere | undefined;
        /** Parse RuledSweepProps to RuledSweep instance. */
        static parseRuledSweep(json?: RuledSweepProps): RuledSweep | undefined;
        /** Parse TorusPipe props to TorusPipe instance. */
        static parseTorusPipe(json?: TorusPipeProps): TorusPipe | undefined;
        /** Parse an array object to array of Point3d instances. */
        static parsePointArray(json?: any[]): Point3d[];
        /** Deserialize `json` to `GeometryQuery` instances. */
        static parse(json?: any): AnyGeometryQuery | any[] | undefined;
    }
    /**
     * Class to deserialize json objects into GeometryQuery objects
     * @public
     */
    class Writer extends GeometryHandler {
        handleTaggedNumericData(data: TaggedNumericData): TaggedNumericDataProps;
        /** Convert strongly typed instance to tagged json */
        handleLineSegment3d(data: LineSegment3d): any;
        /** Convert strongly typed instance to tagged json */
        handleCoordinateXYZ(data: CoordinateXYZ): any;
        /** Convert strongly typed instance to tagged json */
        handleArc3d(data: Arc3d): any;
        /**
         * Insert orientation description to a data object.
         * @param matrix matrix with orientation
         * @param omitIfIdentity omit the axis data if the matrix is an identity.
         * @param data AxesProps object to be annotated.
         */
        private static insertOrientationFromMatrix;
        private static isIdentityXY;
        /**
         * Insert orientation description to a data object.
         * @param matrix matrix with orientation
         * @param omitIfIdentity omit the axis data if the matrix is an identity.
         * @param data AxesProps object to be annotated.
         */
        private static insertOrientationFromXYVectors;
        /**
         * Insert orientation description to a data object, with orientation defined by u and v direction
         * vectors.
         * @param vectorX u direction
         * @param vectorV v direction
         * @param omitIfIdentity omit the axis data if the vectorU and vectorV are global x and y vectors.
         * @param data AxesProps object to be annotated.
         */
        private static insertXYOrientation;
        /** Parse properties of a TransitionSpiral. */
        handleTransitionSpiral(data: TransitionSpiral3d): any;
        /** Convert strongly typed instance to tagged json */
        handleCone(data: Cone): any;
        /** Convert strongly typed instance to tagged json */
        handleSphere(data: Sphere): any;
        /** Convert strongly typed instance to tagged json */
        handleTorusPipe(data: TorusPipe): any;
        /** Convert strongly typed instance to tagged json */
        handleLineString3d(data: LineString3d): any;
        /** Convert strongly typed instance to tagged json */
        handlePointString3d(data: PointString3d): any;
        /** Convert strongly typed instance to tagged json */
        handlePath(data: Path): any;
        /** Convert strongly typed instance to tagged json */
        handleLoop(data: Loop): any;
        /** Convert strongly typed instance to tagged json */
        handleParityRegion(data: ParityRegion): any;
        /** Convert strongly typed instance to tagged json */
        handleUnionRegion(data: UnionRegion): any;
        /** Convert strongly typed instance to tagged json */
        handleBagOfCurves(data: BagOfCurves): any;
        private collectChildren;
        /** Convert strongly typed instance to tagged json */
        handleLinearSweep(data: LinearSweep): any;
        /** Convert strongly typed instance to tagged json */
        handleRuledSweep(data: RuledSweep): any;
        /** Convert strongly typed instance to tagged json */
        handleRotationalSweep(data: RotationalSweep): any;
        /** Convert strongly typed instance to tagged json */
        handleBox(box: Box): any;
        private handlePolyfaceAuxData;
        /** Convert strongly typed instance to tagged json */
        handleIndexedPolyface(pf: IndexedPolyface): any;
        private handleBSplineCurve;
        /** Convert strongly typed instance to tagged json */
        handleBSplineCurve3d(curve: BSplineCurve3d): any;
        /** Convert strongly typed instance to tagged json */
        handleInterpolationCurve3d(curve: InterpolationCurve3d): any;
        /** Convert strongly typed instance to tagged json */
        handleAkimaCurve3d(curve: AkimaCurve3d): any;
        /** Convert strongly typed instance to tagged json */
        handleBezierCurve3d(curve: BezierCurve3d): any;
        /** Convert strongly typed instance to tagged json */
        handleBSplineCurve3dH(curve: BSplineCurve3dH): any;
        /** Convert strongly typed instance to tagged json */
        handleBSplineSurface3d(surface: BSplineSurface3d): any;
        /** Convert strongly typed instance to tagged json */
        handleBezierCurve3dH(curve: BezierCurve3dH): any;
        /** Convert strongly typed instance to tagged json */
        private handleBSplineSurface;
        /** Convert strongly typed instance to tagged json */
        handleBSplineSurface3dH(surface: BSplineSurface3dH): any;
        /** Convert an array of strongly typed instances to an array of tagged json */
        emitArray(data: object[]): any;
        /** Convert GeometryQuery data (array or single instance) to instance to tagged json */
        emit(data: any): any;
        /** One-step static method to create a writer and emit a json object */
        static toIModelJson(data: any): any;
    }
}
//# sourceMappingURL=IModelJsonSchema.d.ts.map