@vcmap/ui 6.3.10 → 7.0.0-rc.1

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;

package/src/components/viewpoint/{VcsViewpointComponent.vue → VcsViewpointComponent.ts.vue}

@@ -10,7 +10,7 @@
         <v-row no-gutters v-if="!hideName">
           <v-col cols="6">
             <VcsLabel :html-for="`${cid}-name`" required>
-              {{ $t('components.viewpoint.name') }}
+              {{ $st('components.viewpoint.name') }}
             </VcsLabel>
           </v-col>
           <v-col>
@@ -25,14 +25,14 @@
         <v-row no-gutters v-if="!hideTitle">
           <v-col cols="6">
             <VcsLabel :html-for="`${cid}-title`">
-              {{ $t('components.viewpoint.title') }}
+              {{ $st('components.viewpoint.title') }}
             </VcsLabel>
           </v-col>
           <v-col>
             <VcsTextField
               :id="`${cid}-title`"
               clearable
-              :placeholder="$t('components.viewpoint.titlePlaceholder')"
+              :placeholder="$st('components.viewpoint.titlePlaceholder')"
               v-model="title"
             />
           </v-col>
@@ -52,7 +52,7 @@
               type="number"
               :min="1"
               unit="s"
-              :title="$t('components.viewpoint.duration')"
+              :title="$st('components.viewpoint.duration')"
               v-model.number="localValue.duration"
             />
           </v-col>
@@ -70,7 +70,7 @@
           <v-row no-gutters>
             <v-col cols="6">
               <VcsLabel html-for="groundPosition">
-                {{ $t('components.viewpoint.groundPosition') }}
+                {{ $st('components.viewpoint.groundPosition') }}
               </VcsLabel>
             </v-col>
           </v-row>
@@ -78,7 +78,7 @@
             :model-value="localValue.groundPosition"
             :disabled="editAction.active"
             @blur="gotoViewpoint"
-            @update:model-value="handleInput('groundPosition')"
+            @update:model-value="(v) => handleInput('groundPosition', v)"
             hide-z
           />
         </template>
@@ -86,7 +86,7 @@
           <v-row no-gutters>
             <v-col cols="6">
               <VcsLabel html-for="cameraPosition">
-                {{ $t('components.viewpoint.cameraPosition') }}
+                {{ $st('components.viewpoint.cameraPosition') }}
               </VcsLabel>
             </v-col>
           </v-row>
@@ -101,7 +101,7 @@
           <v-row no-gutters>
             <v-col>
               <VcsLabel :html-for="`${cid}-distance`">
-                {{ $t('components.viewpoint.distance') }}
+                {{ $st('components.viewpoint.distance') }}
               </VcsLabel>
             </v-col>
             <v-col>
@@ -132,7 +132,7 @@
               allow-text-input
               text-input-cols="3"
               hide-spin-buttons
-              v-bind="hprSliderOptions[key]"
+              v-bind="hprSliderOptions[key as keyof typeof hprSliderOptions]"
               v-model="localValue[key]"
               @blur="gotoViewpoint"
               @update:model-value="gotoViewpoint"
@@ -144,9 +144,11 @@
   </v-sheet>
 </template>
 
-<script>
+<script lang="ts">
+  import type { Coordinate } from 'ol/coordinate.js';
   import {
     computed,
+    defineComponent,
     inject,
     onMounted,
     onUnmounted,
@@ -155,23 +157,28 @@
     toRaw,
     watch,
   } from 'vue';
+  import type { PropType, Ref } from 'vue';
   import { VSheet, VContainer, VRow, VCol } from 'vuetify/components';
   import { CesiumMap, ObliqueMap, OpenlayersMap, Viewpoint } from '@vcmap/core';
-  import VcsFormSection from '../section/VcsFormSection.vue';
-  import VcsLabel from '../form-inputs-controls/VcsLabel.vue';
-  import VcsTextField from '../form-inputs-controls/VcsTextField.vue';
-  import VcsCheckbox from '../form-inputs-controls/VcsCheckbox.vue';
-  import VcsCoordinate from '../form-inputs-controls/VcsCoordinate.vue';
-  import VcsLabeledSlider from '../form-inputs-controls/VcsLabeledSlider.vue';
+  import type { ViewpointOptions } from '@vcmap/core';
+  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 VcsCheckbox from '../form-inputs-controls/VcsCheckbox.ts.vue';
+  import VcsCoordinate from '../form-inputs-controls/VcsCoordinate.ts.vue';
+  import VcsLabeledSlider from '../form-inputs-controls/VcsLabeledSlider.ts.vue';
   import { useProxiedComplexModel } from '../modelHelper.js';
   import { useComponentId } from '../composables.js';
+  import type { VcsAction } from '../../actions/actionHelper.js';
+  import type VcsUiApp from '../../vcsUiApp.js';
 
   /**
    * Updates the localValue ref by keeping name and properties
-   * @param {import("vue").Ref<import("vue").UnwrapRef<import("@vcmap/core").ViewpointOptions>>} localValue
-   * @param {import("@vcmap/core").Viewpoint} viewpoint
    */
-  function updateLocalValueFromViewpoint(localValue, viewpoint) {
+  function updateLocalValueFromViewpoint(
+    localValue: Ref<ViewpointOptions>,
+    viewpoint: Viewpoint,
+  ): void {
     const options = viewpoint.toJSON();
     options.name = localValue.value.name;
     options.animate = localValue.value.animate;
@@ -185,17 +192,18 @@
   /**
    * Set up post render handler, if action is active.
    * If action is inactive, destroy post render handler to allow manual editing.
-   * @param {import("@vcmap/ui").VcsUiApp} app
-   * @param {import("vue").Ref<import("vue").UnwrapRef<import("@vcmap/core").ViewpointOptions>>} localValue
-   * @param {import("vue").Ref<boolean>} isCesiumMap
-   * @param {boolean} startSync - whether to set up post render handler on creation
-   * @returns {{action: import("../../actions/actionHelper.js").VcsAction, destroy: function():void}}
+   * @param startSync - whether to set up post render handler on creation
    */
-  function createEditingAction(app, localValue, isCesiumMap, startSync) {
-    let destroyPostRenderListener = () => {};
+  function createEditingAction(
+    app: VcsUiApp,
+    localValue: Ref<ViewpointOptions>,
+    isCesiumMap: Ref<boolean>,
+    startSync: boolean,
+  ): { action: VcsAction; destroy: () => void } {
+    let destroyPostRenderListener = (): void => {};
     let cachedViewpoint = new Viewpoint(localValue.value);
 
-    function setupPostRenderListener() {
+    function setupPostRenderListener(): void {
       destroyPostRenderListener();
       destroyPostRenderListener = app.maps.postRender.addEventListener(
         ({ map }) => {
@@ -261,38 +269,28 @@
 
     return {
       action,
-      destroy: () => {
+      destroy: (): void => {
         destroyMapListener();
         destroyPostRenderListener();
       },
     };
   }
 
-  /**
-   * @param {number} number
-   * @returns {boolean|string}
-   */
-  export function isFiniteNumber(number) {
+  export function isFiniteNumber(number: number): boolean | string {
     return Number.isFinite(number) || 'components.viewpoint.finiteNumber';
   }
 
-  /**
-   * @param {number} number
-   * @returns {boolean|string}
-   */
-  export function isPositiveNumber(number) {
+  export function isPositiveNumber(number: number): boolean | string {
     return (
       (Number.isFinite(number) && number > 0) ||
       'components.viewpoint.positiveNumber'
     );
   }
 
-  /**
-   * @param {import("@vcmap/ui").VcsUiApp} app
-   * @param {import("@vcmap/core").ViewpointOptions} options
-   * @returns {Promise<void>}
-   */
-  export async function gotoViewpointOptions(app, options) {
+  export async function gotoViewpointOptions(
+    app: VcsUiApp,
+    options: ViewpointOptions,
+  ): Promise<void> {
     const viewpoint = new Viewpoint({
       ...options,
       animate: false,
@@ -313,7 +311,7 @@
    * @vue-prop {boolean} hideGeneral - Hide all general settings (name, title, animate).
    * @vue-prop {Array<(v:string)=>(boolean|string)>} nameRules - Optional rules for name input.
    */
-  export default {
+  export default defineComponent({
     name: 'VcsViewpointComponent',
     components: {
       VSheet,
@@ -329,7 +327,7 @@
     },
     props: {
       modelValue: {
-        type: Object,
+        type: Object as PropType<ViewpointOptions>,
         default: Viewpoint.getDefaultOptions(),
       },
       startSync: {
@@ -357,13 +355,13 @@
         default: false,
       },
       nameRules: {
-        type: Array,
+        type: Array as PropType<Array<(v: string) => boolean | string>>,
         default: () => [],
       },
     },
     emits: ['update:modelValue'],
     setup(props, { emit }) {
-      const app = inject('vcsApp');
+      const app = inject('vcsApp') as VcsUiApp;
       const isCesiumMap = ref(
         app.maps.activeMap?.className === CesiumMap.className,
       );
@@ -371,7 +369,7 @@
 
       const title = computed({
         get() {
-          return localValue.value.properties?.title;
+          return localValue.value.properties?.title as string | undefined;
         },
         set(value) {
           if (localValue.value.properties?.title !== value) {
@@ -385,24 +383,12 @@
       });
 
       const hprSliderOptions = {
-        heading: {
-          min: 0,
-          max: 360,
-          step: 1,
-        },
-        pitch: {
-          min: -90,
-          max: 90,
-          step: 1,
-        },
-        roll: {
-          min: 0,
-          max: 360,
-          step: 1,
-        },
+        heading: { min: 0, max: 360, step: 1 },
+        pitch: { min: -90, max: 90, step: 1 },
+        roll: { min: 0, max: 360, step: 1 },
       };
 
-      const updateFromViewAction = {
+      const updateFromViewAction = reactive<VcsAction>({
         name: 'update-viewpoint-from-view-action',
         icon: 'mdi-camera',
         title: 'components.viewpoint.updateFromView',
@@ -410,11 +396,11 @@
           if (app.maps.activeMap) {
             updateLocalValueFromViewpoint(
               localValue,
-              await app.maps.activeMap.getViewpoint(),
+              (await app.maps.activeMap.getViewpoint()) as Viewpoint,
             );
           }
         },
-      };
+      });
 
       const { action: editAction, destroy } = createEditingAction(
         app,
@@ -428,8 +414,9 @@
        */
       const mapWatcher = watch(isCesiumMap, () => {
         if (isCesiumMap.value && !localValue.value.cameraPosition) {
-          localValue.value.cameraPosition =
+          const cameraPosition =
             app.maps.activeMap?.getViewpointSync()?.cameraPosition;
+          localValue.value.cameraPosition = cameraPosition ?? undefined;
         }
       });
 
@@ -450,19 +437,22 @@
         disabledWatcher();
       });
 
-      async function gotoViewpoint() {
+      async function gotoViewpoint(): Promise<void> {
         await gotoViewpointOptions(app, localValue.value);
       }
 
-      async function handleInput(key, value) {
+      async function handleInput(
+        key: 'groundPosition' | 'cameraPosition',
+        value: Coordinate | undefined,
+      ): Promise<void> {
         localValue.value[key] = value;
         if (app.maps.activeMap) {
           if (key === 'groundPosition') {
             localValue.value.cameraPosition = undefined;
           } else if (key === 'cameraPosition') {
-            localValue.value.groundPosition = (
-              await app.maps.activeMap.getViewpoint()
-            ).groundPosition;
+            const { groundPosition } =
+              (await app.maps.activeMap.getViewpoint()) as Viewpoint;
+            localValue.value.groundPosition = groundPosition ?? undefined;
           }
           await gotoViewpoint();
         }
@@ -484,5 +474,5 @@
         cid,
       };
     },
-  };
+  });
 </script>