'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
var composables = require('../composables');
var util = require('../utils/util');
var cesiumProps = require('../utils/cesium-props');

/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

function __awaiter(thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

var VcGeometryBox = vue.defineComponent({
    name: 'VcGeometryBox',
    props: Object.assign(Object.assign({}, cesiumProps.dimensions), cesiumProps.vertexFormat),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'BoxGeometry';
        const geometriesState = composables.useGeometries(props, ctx, instance);
        instance.createCesiumObject = () => __awaiter(this, void 0, void 0, function* () {
            const options = geometriesState.transformProps(props);
            return Cesium.BoxGeometry.fromDimensions(options);
        });
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryBoxOutline = vue.defineComponent({
    name: 'VcGeometryBoxOutline',
    props: Object.assign({}, cesiumProps.dimensions),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'BoxOutlineGeometry';
        const geometriesState = composables.useGeometries(props, ctx, instance);
        instance.createCesiumObject = () => __awaiter(this, void 0, void 0, function* () {
            const options = geometriesState.transformProps(props);
            return Cesium.BoxOutlineGeometry.fromDimensions(options);
        });
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryCircle = vue.defineComponent({
    name: 'VcGeometryCircle',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.center), cesiumProps.radius), cesiumProps.ellipsoid), cesiumProps.height), cesiumProps.granularity), cesiumProps.vertexFormat), cesiumProps.extrudedHeight), cesiumProps.stRotation),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'CircleGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryCircleOutline = vue.defineComponent({
    name: 'VcGeometryCircleOutline',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.center), cesiumProps.radius), cesiumProps.ellipsoid), cesiumProps.height), cesiumProps.granularity), cesiumProps.extrudedHeight), cesiumProps.numberOfVerticalLines),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'CircleOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryPolygonCoplanar = vue.defineComponent({
    name: 'VcGeometryPolygonCoplanar',
    props: Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.polygonHierarchy), cesiumProps.ellipsoid), cesiumProps.vertexFormat), cesiumProps.stRotation),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'CoplanarPolygonGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryPolygonCoplanarOutline = vue.defineComponent({
    name: 'VcGeometryPolygonCoplanarOutline',
    props: Object.assign({}, cesiumProps.polygonHierarchy),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'CoplanarPolygonOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryCorridor = vue.defineComponent({
    name: 'VcGeometryCorridor',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.positions), cesiumProps.width), cesiumProps.ellipsoid), cesiumProps.granularity), cesiumProps.height), cesiumProps.extrudedHeight), cesiumProps.vertexFormat), cesiumProps.cornerType),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'CorridorGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryCorridorOutline = vue.defineComponent({
    name: 'VcGeometryCorridorOutline',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.positions), cesiumProps.width), cesiumProps.ellipsoid), cesiumProps.granularity), cesiumProps.height), cesiumProps.extrudedHeight), cesiumProps.cornerType),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'CorridorOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryCylinder = vue.defineComponent({
    name: 'VcGeometryCylinder',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.length), cesiumProps.topRadius), cesiumProps.bottomRadius), cesiumProps.slices), cesiumProps.vertexFormat),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'CylinderGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryCylinderOutline = vue.defineComponent({
    name: 'VcGeometryCylinderOutline',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.length), cesiumProps.topRadius), cesiumProps.bottomRadius), cesiumProps.slices), cesiumProps.numberOfVerticalLines),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'CylinderOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryEllipse = vue.defineComponent({
    name: 'VcGeometryEllipse',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.center), cesiumProps.semiMajorAxis), cesiumProps.semiMinorAxis), cesiumProps.ellipsoid), cesiumProps.height), cesiumProps.extrudedHeight), cesiumProps.rotation), cesiumProps.stRotation), cesiumProps.granularity), cesiumProps.vertexFormat),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'EllipseGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryEllipseOutline = vue.defineComponent({
    name: 'VcGeometryEllipseOutline',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.center), cesiumProps.semiMajorAxis), cesiumProps.semiMinorAxis), cesiumProps.ellipsoid), cesiumProps.height), cesiumProps.extrudedHeight), cesiumProps.rotation), cesiumProps.stRotation), cesiumProps.granularity), cesiumProps.numberOfVerticalLines),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'EllipseOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryEllipsoid = vue.defineComponent({
    name: 'VcGeometryEllipsoid',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.radii), cesiumProps.innerRadii), cesiumProps.minimumClock), cesiumProps.maximumClock), cesiumProps.minimumCone), cesiumProps.maximumCone), cesiumProps.stackPartitions), cesiumProps.slicePartitions), cesiumProps.vertexFormat),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'EllipsoidGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryEllipsoidOutline = vue.defineComponent({
    name: 'VcGeometryEllipsoidOutline',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.radii), cesiumProps.innerRadii), cesiumProps.minimumClock), cesiumProps.maximumClock), cesiumProps.minimumCone), cesiumProps.maximumCone), cesiumProps.stackPartitions), cesiumProps.slicePartitions), cesiumProps.subdivisions),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'EllipsoidOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryFrustum = vue.defineComponent({
    name: 'VcGeometryFrustum',
    props: Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.frustum), cesiumProps.origin), cesiumProps.orientation), cesiumProps.vertexFormat),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'FrustumGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryFrustumOutline = vue.defineComponent({
    name: 'VcGeometryFrustumOutline',
    props: Object.assign(Object.assign(Object.assign({}, cesiumProps.frustum), cesiumProps.origin), cesiumProps.orientation),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'FrustumOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryPolylineGround = vue.defineComponent({
    name: 'VcGeometryPolylineGround',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.positions), cesiumProps.width), cesiumProps.granularity), cesiumProps.loop), cesiumProps.arcType),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'GroundPolylineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryPlane = vue.defineComponent({
    name: 'VcGeometryPlane',
    props: Object.assign({}, cesiumProps.vertexFormat),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'PlaneGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryPlaneOutline = vue.defineComponent({
    name: 'VcGeometryPlaneOutline',
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'PlaneOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryPolygon = vue.defineComponent({
    name: 'VcGeometryPolygon',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.polygonHierarchy), cesiumProps.height), cesiumProps.extrudedHeight), cesiumProps.vertexFormat), cesiumProps.stRotation), cesiumProps.ellipsoid), cesiumProps.granularity), cesiumProps.perPositionHeight), cesiumProps.closeTop), cesiumProps.closeBottom), cesiumProps.arcType),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'PolygonGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryPolygonOutline = vue.defineComponent({
    name: 'VcGeometryPolygonOutline',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.polygonHierarchy), cesiumProps.height), cesiumProps.extrudedHeight), cesiumProps.vertexFormat), cesiumProps.ellipsoid), cesiumProps.granularity), cesiumProps.perPositionHeight), cesiumProps.arcType),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'PolygonOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryPolyline = vue.defineComponent({
    name: 'VcGeometryPolyline',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.positions), cesiumProps.width), cesiumProps.colors), { colorsPerVertex: {
            type: Boolean,
            default: false
        } }), cesiumProps.arcType), cesiumProps.granularity), cesiumProps.vertexFormat), cesiumProps.ellipsoid),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'PolylineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryPolylineVolume = vue.defineComponent({
    name: 'VcGeometryPolylineVolume',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.polylinePositions), cesiumProps.shapePositions), cesiumProps.ellipsoid), cesiumProps.granularity), cesiumProps.vertexFormat), cesiumProps.cornerType),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'PolylineVolumeGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryPolylineVolumeOutline = vue.defineComponent({
    name: 'VcGeometryPolylineVolumeOutline',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.polylinePositions), cesiumProps.shapePositions), cesiumProps.ellipsoid), cesiumProps.granularity), cesiumProps.cornerType),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'PolylineVolumeOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryRectangle = vue.defineComponent({
    name: 'VcGeometryRectangle',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.rectangle), cesiumProps.vertexFormat), cesiumProps.ellipsoid), cesiumProps.granularity), cesiumProps.height), cesiumProps.rotation), cesiumProps.stRotation), cesiumProps.extrudedHeight),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'RectangleGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryRectangleOutline = vue.defineComponent({
    name: 'VcGeometryRectangleOutline',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.rectangle), cesiumProps.ellipsoid), cesiumProps.granularity), cesiumProps.height), cesiumProps.rotation), cesiumProps.extrudedHeight),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'RectangleOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryPolylineSimple = vue.defineComponent({
    name: 'VcGeometryPolylineSimple',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.positions), cesiumProps.colors), { colorsPerVertex: {
            type: Boolean,
            default: false
        } }), cesiumProps.arcType), cesiumProps.granularity), cesiumProps.ellipsoid),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'SimplePolylineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometrySphere = vue.defineComponent({
    name: 'VcGeometrySphere',
    props: Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.radius), cesiumProps.stackPartitions), cesiumProps.slicePartitions), cesiumProps.vertexFormat),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'SphereGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometrySphereOutline = vue.defineComponent({
    name: 'VcGeometrySphereOutline',
    props: Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.radius), cesiumProps.stackPartitions), cesiumProps.slicePartitions), cesiumProps.subdivisions),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'SphereOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryWall = vue.defineComponent({
    name: 'VcGeometryWall',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.positions), cesiumProps.granularity), cesiumProps.maximumHeights), cesiumProps.minimumHeights), cesiumProps.ellipsoid), cesiumProps.vertexFormat),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'WallGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

var VcGeometryWallOutline = vue.defineComponent({
    name: 'VcGeometryWallOutline',
    props: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cesiumProps.positions), cesiumProps.granularity), cesiumProps.maximumHeights), cesiumProps.minimumHeights), cesiumProps.ellipsoid),
    emits: ['beforeLoad', 'ready', 'destroyed'],
    setup(props, ctx) {
        const instance = vue.getCurrentInstance();
        instance.cesiumClass = 'WallOutlineGeometry';
        composables.useGeometries(props, ctx, instance);
        return () => vue.createCommentVNode(util.kebabCase(instance.proxy.$options.name));
    }
});

const components = [
    VcGeometryBox,
    VcGeometryBoxOutline,
    VcGeometryCircle,
    VcGeometryCircleOutline,
    VcGeometryPolygonCoplanar,
    VcGeometryPolygonCoplanarOutline,
    VcGeometryCorridor,
    VcGeometryCorridorOutline,
    VcGeometryCylinder,
    VcGeometryCylinderOutline,
    VcGeometryEllipse,
    VcGeometryEllipseOutline,
    VcGeometryEllipsoid,
    VcGeometryEllipsoidOutline,
    VcGeometryFrustum,
    VcGeometryFrustumOutline,
    VcGeometryPolylineGround,
    VcGeometryPlane,
    VcGeometryPlaneOutline,
    VcGeometryPolygon,
    VcGeometryPolygonOutline,
    VcGeometryPolyline,
    VcGeometryPolylineVolume,
    VcGeometryPolylineVolumeOutline,
    VcGeometryRectangle,
    VcGeometryRectangleOutline,
    VcGeometryPolylineSimple,
    VcGeometrySphere,
    VcGeometrySphereOutline,
    VcGeometryWall,
    VcGeometryWallOutline
];
const install = (app) => {
    components.forEach(cmp => {
        app.component(cmp.name, cmp);
    });
};
var index = {
    install
};

exports.VcGeometryBox = VcGeometryBox;
exports.VcGeometryBoxOutline = VcGeometryBoxOutline;
exports.VcGeometryCircle = VcGeometryCircle;
exports.VcGeometryCircleOutline = VcGeometryCircleOutline;
exports.VcGeometryCorridor = VcGeometryCorridor;
exports.VcGeometryCorridorOutline = VcGeometryCorridorOutline;
exports.VcGeometryCylinder = VcGeometryCylinder;
exports.VcGeometryCylinderOutline = VcGeometryCylinderOutline;
exports.VcGeometryEllipse = VcGeometryEllipse;
exports.VcGeometryEllipseOutline = VcGeometryEllipseOutline;
exports.VcGeometryEllipsoid = VcGeometryEllipsoid;
exports.VcGeometryEllipsoidOutline = VcGeometryEllipsoidOutline;
exports.VcGeometryFrustum = VcGeometryFrustum;
exports.VcGeometryFrustumOutline = VcGeometryFrustumOutline;
exports.VcGeometryPlane = VcGeometryPlane;
exports.VcGeometryPlaneOutline = VcGeometryPlaneOutline;
exports.VcGeometryPolygon = VcGeometryPolygon;
exports.VcGeometryPolygonCoplanar = VcGeometryPolygonCoplanar;
exports.VcGeometryPolygonCoplanarOutline = VcGeometryPolygonCoplanarOutline;
exports.VcGeometryPolygonOutline = VcGeometryPolygonOutline;
exports.VcGeometryPolyline = VcGeometryPolyline;
exports.VcGeometryPolylineGround = VcGeometryPolylineGround;
exports.VcGeometryPolylineSimple = VcGeometryPolylineSimple;
exports.VcGeometryPolylineVolume = VcGeometryPolylineVolume;
exports.VcGeometryPolylineVolumeOutline = VcGeometryPolylineVolumeOutline;
exports.VcGeometryRectangle = VcGeometryRectangle;
exports.VcGeometryRectangleOutline = VcGeometryRectangleOutline;
exports.VcGeometrySphere = VcGeometrySphere;
exports.VcGeometrySphereOutline = VcGeometrySphereOutline;
exports.VcGeometryWall = VcGeometryWall;
exports.VcGeometryWallOutline = VcGeometryWallOutline;
exports.default = index;
