@vcmap/ui 6.3.11 → 7.0.0-rc.1

package/src/components/vector-properties/VcsFeatureTransforms.vue.d.ts

@@ -1,4 +1,6 @@
-declare const _default: import("vue").DefineComponent<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
     transformationMode: {
         type: StringConstructor;
         required: true;
@@ -12,21 +14,21 @@ declare const _default: import("vue").DefineComponent<{
         default: boolean;
     };
 }, {
-    showTranslate: import("vue").Ref<boolean>;
-    showRotate: import("vue").Ref<boolean>;
-    showScale: import("vue").Ref<boolean>;
+    showTranslate: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+    showRotate: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
+    showScale: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
     TransformationMode: typeof TransformationMode;
-    xValue: import("vue").Ref<null>;
-    yValue: import("vue").Ref<null>;
-    zValue: import("vue").Ref<null>;
+    xValue: import("vue", { with: { "resolution-mode": "import" } }).Ref<null>;
+    yValue: import("vue", { with: { "resolution-mode": "import" } }).Ref<null>;
+    zValue: import("vue", { with: { "resolution-mode": "import" } }).Ref<null>;
     translate(): Promise<void>;
     rotate(): Promise<void>;
     cw(): Promise<void>;
     ccw(): Promise<void>;
     scale(): Promise<void>;
-    placeOnTerrainLoading: import("vue").Ref<boolean>;
+    placeOnTerrainLoading: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
     placeOnTerrain(): Promise<void>;
-}, any, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, any, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, {}, string, import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
     transformationMode: {
         type: StringConstructor;
         required: true;
@@ -42,5 +44,4 @@ declare const _default: import("vue").DefineComponent<{
 }>>, {
     allowZInput: boolean;
 }, {}>;
-export default _default;
 import { TransformationMode } from '@vcmap/core';

package/src/components/vector-properties/{VcsSnapTo.vue → VcsSnapTo.ts.vue}

@@ -1,10 +1,12 @@
-<script setup>
-  import { computed, defineModel, reactive } from 'vue';
+<script setup lang="ts">
+  import { computed, reactive } from 'vue';
+  import type { PropType } from 'vue';
   import { snapTypes } from '@vcmap/core';
-  import VcsFormSection from '../section/VcsFormSection.vue';
+  import type { VcsAction } from '../../actions/actionHelper.js';
+  import VcsFormSection from '../section/VcsFormSection.ts.vue';
 
   const model = defineModel({
-    type: Array,
+    type: Array as PropType<string[]>,
     required: false,
     default: () => snapTypes.slice(),
   });
@@ -16,7 +18,7 @@
     edge: 'mdi-circle-outline',
   };
 
-  function createToggleAction(key) {
+  function createToggleAction(key: keyof typeof keyIcons): VcsAction {
     const keyComputed = computed({
       get() {
         return model.value.includes(key);
@@ -31,7 +33,7 @@
     });
 
     return reactive({
-      name: `toggele${key}`,
+      name: `toggle${key}`,
       icon: keyIcons[key],
       title: `components.editor.snapping.${key}Tooltip`,
       active: keyComputed,
@@ -56,7 +58,7 @@
     :action-button-list-overflow-count="4"
   >
     <div class="px-1 py-1">
-      {{ $t('components.editor.snapping.help') }}
+      {{ $st('components.editor.snapping.help') }}
     </div>
   </vcs-form-section>
 </template>

package/src/components/vector-properties/VcsSnapTo.ts.vue.d.ts

@@ -0,0 +1,19 @@
+declare const model: import("vue", { with: { "resolution-mode": "import" } }).ModelRef<string[], string>;
+type __VLS_ModelProps = {
+    modelValue?: typeof model['value'];
+};
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<__VLS_TypePropsToOption<__VLS_ModelProps>, unknown, unknown, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, {
+    "update:modelValue": (value: string[]) => void;
+}, string, import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<__VLS_TypePropsToOption<__VLS_ModelProps>>> & {
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+}, {}, {}>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/src/components/vector-properties/VcsVectorPropertiesComponent.vue

@@ -480,14 +480,14 @@
   import {
     useProxiedComplexModel,
     useModelHasProperty,
-  } from '../modelHelper.js';
-  import VcsFormSection from '../section/VcsFormSection.vue';
-  import VcsLabel from '../form-inputs-controls/VcsLabel.vue';
-  import VcsTextField from '../form-inputs-controls/VcsTextField.vue';
-  import VcsSelect from '../form-inputs-controls/VcsSelect.vue';
-  import VcsCheckbox from '../form-inputs-controls/VcsCheckbox.vue';
-  import VcsChipArrayInput from '../form-inputs-controls/VcsChipArrayInput.vue';
-  import { useComponentId } from '../composables.js';
+  } from '../modelHelper.ts';
+  import VcsFormSection from '../section/VcsFormSection.ts.vue';
+  import VcsLabel from '../form-inputs-controls/VcsLabel.ts.vue';
+  import VcsTextField from '../form-inputs-controls/VcsTextField.ts.vue';
+  import VcsSelect from '../form-inputs-controls/VcsSelect.ts.vue';
+  import VcsCheckbox from '../form-inputs-controls/VcsCheckbox.ts.vue';
+  import VcsChipArrayInput from '../form-inputs-controls/VcsChipArrayInput.ts.vue';
+  import { useComponentId } from '../composables.ts';
 
   export const genericVectorProperties = [
     'altitudeMode',

package/src/components/vector-properties/VcsVectorPropertiesComponent.vue.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="@vcmap-cesium/engine" />
-/// <reference types="@vcmap/core/dist/cesium.js" />
 export const genericVectorProperties: string[];
 export const pointVectorProperties: string[];
 export const nonPointVectorProperties: string[];
@@ -7,7 +5,9 @@ export const vectorProperties: string[];
 export const scaleByDistanceDefault: number[];
 export const eyeOffsetDefault: number[];
 export const dimensionsUpperCase: string[];
-declare const _default: import("vue").DefineComponent<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
     modelValue: {
         type: ObjectConstructor;
         default: () => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions;
@@ -49,76 +49,76 @@ declare const _default: import("vue").DefineComponent<{
         default: boolean;
     };
 }, {
-    localValue: import("vue").Ref<{
+    localValue: import("vue", { with: { "resolution-mode": "import" } }).Ref<{
         readonly propertyChanged: {
             readonly numberOfListeners: number;
-            addEventListener: (listener: (event: import("@vcmap/core/dist/src/layer/vectorProperties.js", { with: { "resolution-mode": "import" } }).PropertyChangedKey[]) => void | Promise<void>) => () => void;
-            removeEventListener: (listener: (event: import("@vcmap/core/dist/src/layer/vectorProperties.js", { with: { "resolution-mode": "import" } }).PropertyChangedKey[]) => void | Promise<void>) => boolean;
+            addEventListener: (listener: (event: import("@vcmap/core/dist/src/layer/vectorProperties.js", { with: { "resolution-mode": "import" } }).PropertyChangedKey[]) => Promise<void> | void) => () => void;
+            removeEventListener: (listener: (event: import("@vcmap/core/dist/src/layer/vectorProperties.js", { with: { "resolution-mode": "import" } }).PropertyChangedKey[]) => Promise<void> | void) => boolean;
             raiseEvent: (event: import("@vcmap/core/dist/src/layer/vectorProperties.js", { with: { "resolution-mode": "import" } }).PropertyChangedKey[]) => void;
             awaitRaisedEvent: (event: import("@vcmap/core/dist/src/layer/vectorProperties.js", { with: { "resolution-mode": "import" } }).PropertyChangedKey[]) => Promise<void>;
             destroy: () => void;
         };
         altitudeMode: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).HeightReference;
-        getAltitudeMode: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).HeightReference;
+        getAltitudeMode: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).HeightReference;
         allowPicking: boolean;
-        getAllowPicking: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => boolean;
+        getAllowPicking: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => boolean;
         classificationType: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).ClassificationType | undefined;
-        getClassificationType: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).ClassificationType | undefined;
+        getClassificationType: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).ClassificationType | undefined;
         scaleByDistance: {
             near: number;
             nearValue: number;
             far: number;
             farValue: number;
-            clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).NearFarScalar | undefined) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).NearFarScalar;
-            equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).NearFarScalar | undefined) => boolean;
+            clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).NearFarScalar) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).NearFarScalar;
+            equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).NearFarScalar) => boolean;
         } | undefined;
-        getScaleByDistance: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).NearFarScalar | undefined;
+        getScaleByDistance: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).NearFarScalar | undefined;
         eyeOffset: {
             x: number;
             y: number;
             z: number;
-            clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
-            equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => boolean;
-            equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined, relativeEpsilon?: number | undefined, absoluteEpsilon?: number | undefined) => boolean;
+            clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
+            equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => boolean;
+            equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3, relativeEpsilon?: number, absoluteEpsilon?: number) => boolean;
             toString: () => string;
         } | undefined;
-        getEyeOffset: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined;
+        getEyeOffset: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined;
         heightAboveGround: number | undefined;
-        getHeightAboveGround: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number | undefined;
+        getHeightAboveGround: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number | undefined;
         skirt: number;
-        getSkirt: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number;
+        getSkirt: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number;
         groundLevel: number | undefined;
-        getGroundLevel: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number | undefined;
+        getGroundLevel: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number | undefined;
         extrudedHeight: number;
-        getExtrudedHeight: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number;
+        getExtrudedHeight: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number;
         storeysAboveGround: number;
-        getStoreysAboveGround: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number;
+        getStoreysAboveGround: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number;
         storeysBelowGround: number;
-        getStoreysBelowGround: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number;
+        getStoreysBelowGround: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number;
         storeyHeightsAboveGround: number[];
-        getStoreyHeightsAboveGround: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number[];
+        getStoreyHeightsAboveGround: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number[];
         storeyHeightsBelowGround: number[];
-        getStoreyHeightsBelowGround: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number[];
+        getStoreyHeightsBelowGround: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number[];
         modelUrl: string | undefined;
-        getModelUrl: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => string | undefined;
+        getModelUrl: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => string | undefined;
         modelScaleX: number;
-        getModelScaleX: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number;
+        getModelScaleX: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number;
         modelScaleY: number;
-        getModelScaleY: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number;
+        getModelScaleY: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number;
         modelScaleZ: number;
-        getModelScaleZ: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number;
+        getModelScaleZ: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number;
         modelHeading: number;
-        getModelHeading: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number;
+        getModelHeading: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number;
         modelPitch: number;
-        getModelPitch: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number;
+        getModelPitch: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number;
         modelRoll: number;
-        getModelRoll: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => number;
+        getModelRoll: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => number;
         modelOptions: Record<string, unknown> | undefined;
-        getModelOptions: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => Record<string, unknown> | undefined;
+        getModelOptions: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => Record<string, unknown> | undefined;
         modelAutoScale: boolean;
-        getModelAutoScale: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => boolean;
+        getModelAutoScale: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => boolean;
         baseUrl: string | undefined;
-        getBaseUrl: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => string | undefined;
+        getBaseUrl: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => string | undefined;
         primitiveOptions: {
             type: import("@vcmap/core", { with: { "resolution-mode": "import" } }).PrimitiveOptionsType;
             geometryOptions: {
@@ -151,18 +151,18 @@ declare const _default: import("vue").DefineComponent<{
                     x: number;
                     y: number;
                     z: number;
-                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
-                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => boolean;
-                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined, relativeEpsilon?: number | undefined, absoluteEpsilon?: number | undefined) => boolean;
+                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
+                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => boolean;
+                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3, relativeEpsilon?: number, absoluteEpsilon?: number) => boolean;
                     toString: () => string;
                 } | undefined;
                 innerRadii?: {
                     x: number;
                     y: number;
                     z: number;
-                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
-                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => boolean;
-                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined, relativeEpsilon?: number | undefined, absoluteEpsilon?: number | undefined) => boolean;
+                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
+                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => boolean;
+                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3, relativeEpsilon?: number, absoluteEpsilon?: number) => boolean;
                     toString: () => string;
                 } | undefined;
                 minimumClock?: number | undefined;
@@ -184,18 +184,18 @@ declare const _default: import("vue").DefineComponent<{
                     x: number;
                     y: number;
                     z: number;
-                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
-                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => boolean;
-                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined, relativeEpsilon?: number | undefined, absoluteEpsilon?: number | undefined) => boolean;
+                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
+                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => boolean;
+                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3, relativeEpsilon?: number, absoluteEpsilon?: number) => boolean;
                     toString: () => string;
                 };
                 maximum: {
                     x: number;
                     y: number;
                     z: number;
-                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
-                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined) => boolean;
-                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3 | undefined, relativeEpsilon?: number | undefined, absoluteEpsilon?: number | undefined) => boolean;
+                    clone: (result?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3;
+                    equals: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3) => boolean;
+                    equalsEpsilon: (right?: import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).Cartesian3, relativeEpsilon?: number, absoluteEpsilon?: number) => boolean;
                     toString: () => string;
                 };
                 vertexFormat?: {
@@ -208,33 +208,33 @@ declare const _default: import("vue").DefineComponent<{
                 } | undefined;
             } | undefined;
             depthFailColor?: string | number[] | {
-                setTransform: (transform?: DOMMatrix2DInit | undefined) => void;
+                setTransform: (transform?: DOMMatrix2DInit) => void;
             } | {
                 addColorStop: (offset: number, color: string) => void;
             } | undefined;
             offset?: number[] | undefined;
             additionalOptions?: Record<string, unknown> | undefined;
         } | undefined;
-        getPrimitiveOptions: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesPrimitiveOptions<import("@vcmap/core", { with: { "resolution-mode": "import" } }).PrimitiveOptionsType> | undefined;
-        getPrimitive: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesPrimitive | null;
-        getModel: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesModelOptions | null;
-        renderAs: (feature: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>) => "geometry" | "primitive" | "model";
+        getPrimitiveOptions: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesPrimitiveOptions | undefined;
+        getPrimitive: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesPrimitive | null;
+        getModel: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesModelOptions | null;
+        renderAs: (feature: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature) => "geometry" | "model" | "primitive";
         setVcsMeta: (vcsMeta: import("@vcmap/core", { with: { "resolution-mode": "import" } }).VcsMeta) => void;
         setValues: (options: import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions) => void;
         getValues: () => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions;
-        getValuesForFeatures: (features: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>[]) => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions;
-        setValuesForFeatures: (options: import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions, features: import("ol/Feature.js", { with: { "resolution-mode": "import" } }).default<import("ol/geom.js", { with: { "resolution-mode": "import" } }).Geometry>[]) => void;
-        getVcsMeta: (defaultOptions?: import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions | undefined) => Omit<import("@vcmap/core", { with: { "resolution-mode": "import" } }).VcsMeta, "version">;
+        getValuesForFeatures: (features: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature[]) => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions;
+        setValuesForFeatures: (options: import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions, features: import("ol/index.js", { with: { "resolution-mode": "import" } }).Feature[]) => void;
+        getVcsMeta: (defaultOptions?: import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions) => Omit<import("@vcmap/core", { with: { "resolution-mode": "import" } }).VcsMeta, "version">;
         destroy: () => void;
     }>;
-    headerActions: import("vue").ComputedRef<{
+    headerActions: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<{
         name: string;
         title: string;
         icon: string;
         callback: () => void;
     }[]>;
-    visibleProperties: import("vue").ComputedRef<Set<unknown>>;
-    availableAltitudeModes: import("vue").ComputedRef<({
+    visibleProperties: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<Set<unknown>>;
+    availableAltitudeModes: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<({
         value: string;
         title: string;
         props?: undefined;
@@ -249,18 +249,18 @@ declare const _default: import("vue").DefineComponent<{
         value: string;
         title: string;
     }[];
-    classificationType: import("vue").WritableComputedRef<"none" | import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).ClassificationType.CESIUM_3D_TILE | import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).ClassificationType.BOTH | undefined>;
-    hasScaleByDistance: import("vue").WritableComputedRef<boolean>;
+    classificationType: import("vue", { with: { "resolution-mode": "import" } }).WritableComputedRef<"none" | import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).ClassificationType.CESIUM_3D_TILE | import("@vcmap-cesium/engine", { with: { "resolution-mode": "import" } }).ClassificationType.BOTH | undefined>;
+    hasScaleByDistance: import("vue", { with: { "resolution-mode": "import" } }).WritableComputedRef<boolean>;
     scaleByDistanceDefault: number[];
-    hasEyeOffset: import("vue").WritableComputedRef<boolean>;
+    hasEyeOffset: import("vue", { with: { "resolution-mode": "import" } }).WritableComputedRef<boolean>;
     eyeOffsetDefault: number[];
-    storeyHeights: import("vue").ComputedRef<{}>;
-    modelScale: import("vue").ComputedRef<{}>;
+    storeyHeights: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<{}>;
+    modelScale: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<{}>;
     dimensionsUpperCase: string[];
     cid: string;
 }, any, {}, {
     computed: typeof import("@vue/reactivity").computed;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
     modelValue: {
         type: ObjectConstructor;
         default: () => import("@vcmap/core", { with: { "resolution-mode": "import" } }).VectorPropertiesOptions;
@@ -305,13 +305,12 @@ declare const _default: import("vue").DefineComponent<{
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
 }, {
     modelValue: Record<string, any>;
-    properties: unknown[];
     expandable: boolean;
     startOpen: boolean;
+    properties: unknown[];
+    showReset: boolean;
     altitudeModes: unknown[];
     show3DProperties: boolean;
     is2DFeature: boolean;
     showDividers: boolean;
-    showReset: boolean;
 }, {}>;
-export default _default;