@vcmap/ui 6.3.10 → 7.0.0-rc.1

package/src/components/viewpoint/VcsViewpointComponent.ts.vue.d.ts

@@ -0,0 +1,160 @@
+import type { Coordinate } from 'ol/coordinate.js';
+import type { PropType, Ref } from 'vue';
+import type { ViewpointOptions } from '@vcmap/core';
+import type { VcsAction } from '../../actions/actionHelper.js';
+import type VcsUiApp from '../../vcsUiApp.js';
+export declare function isFiniteNumber(number: number): boolean | string;
+export declare function isPositiveNumber(number: number): boolean | string;
+export declare function gotoViewpointOptions(app: VcsUiApp, options: ViewpointOptions): Promise<void>;
+/**
+ * @description A component to model @vcmap/core/ViewpointOptions. Stops playing flights on mounted.
+ * @vue-prop {import("@vcmap/core").ViewpointOptions} value - The ViewpointOptions that should be modelled.
+ * @vue-prop {boolean} [startSync=true] - Set false to start in manual edit mode, without camera synchronization.
+ * @vue-prop {boolean} [expandable] - Expandable sections.
+ * @vue-prop {boolean} hideName - Hide name input.
+ * @vue-prop {boolean} hideTitle - Hide title input.
+ * @vue-prop {boolean} hideAnimate - Hide animate & duration input.
+ * @vue-prop {boolean} hideGeneral - Hide all general settings (name, title, animate).
+ * @vue-prop {Array<(v:string)=>(boolean|string)>} nameRules - Optional rules for name input.
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
+    modelValue: {
+        type: PropType<ViewpointOptions>;
+        default: ViewpointOptions;
+    };
+    startSync: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expandable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideName: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideTitle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideAnimate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideGeneral: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nameRules: {
+        type: PropType<Array<(v: string) => boolean | string>>;
+        default: () => never[];
+    };
+}, {
+    isCesiumMap: Ref<boolean>;
+    localValue: Ref<ViewpointOptions>;
+    title: import("vue", { with: { "resolution-mode": "import" } }).WritableComputedRef<string | undefined>;
+    gotoViewpoint: () => Promise<void>;
+    handleInput: (key: "groundPosition" | "cameraPosition", value: Coordinate | undefined) => Promise<void>;
+    updateFromViewAction: {
+        /**
+         * - reactive and translatable name rendered in overflow
+         */
+        name: string;
+        /**
+         * - reactive and translatable title rendered as tooltip
+         */
+        title?: string | undefined;
+        /**
+         * - icon rendered on the button. If no icon provided, item is rendered in overflow
+         */
+        icon?: string | undefined;
+        /**
+         * - callback function is triggered when the button is clicked
+         */
+        callback: import("../../actions/actionHelper.js", { with: { "resolution-mode": "import" } }).ActionCallback;
+        /**
+         * - optional state of button. If active, button is rendered in primary color
+         */
+        active?: boolean | undefined;
+        /**
+         * - optional hasUpdate of button. If true, a yellow notification is rendered next to the button
+         */
+        hasUpdate?: boolean | undefined;
+        /**
+         * - optional background state. If active and background, button is rendered in primary color outlined
+         */
+        background?: boolean | undefined;
+        /**
+         * - optional flag to indicate that the action is disabled
+         */
+        disabled?: boolean | undefined;
+    };
+    editAction: VcsAction;
+    hprSliderOptions: {
+        heading: {
+            min: number;
+            max: number;
+            step: number;
+        };
+        pitch: {
+            min: number;
+            max: number;
+            step: number;
+        };
+        roll: {
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    isFiniteNumber: typeof isFiniteNumber;
+    isPositiveNumber: typeof isPositiveNumber;
+    cid: string;
+}, unknown, {}, {}, 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: PropType<ViewpointOptions>;
+        default: ViewpointOptions;
+    };
+    startSync: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expandable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideName: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideTitle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideAnimate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideGeneral: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nameRules: {
+        type: PropType<Array<(v: string) => boolean | string>>;
+        default: () => never[];
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    modelValue: ViewpointOptions;
+    expandable: boolean;
+    startSync: boolean;
+    hideName: boolean;
+    hideTitle: boolean;
+    hideAnimate: boolean;
+    hideGeneral: boolean;
+    nameRules: ((v: string) => boolean | string)[];
+}, {}>;

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

@@ -16,22 +16,23 @@
   </AbstractConfigEditor>
 </template>
 
-<script>
-  import { inject, onUnmounted, ref, toRaw } from 'vue';
+<script lang="ts">
+  import type { PropType } from 'vue';
+  import { defineComponent, inject, onUnmounted, ref, toRaw } from 'vue';
+  import type { ViewpointOptions } from '@vcmap/core';
   import { getLogger } from '@vcsuite/logger';
   import deepEqual from 'fast-deep-equal';
-  import AbstractConfigEditor from '../plugins/AbstractConfigEditor.vue';
+  import AbstractConfigEditor from '../plugins/AbstractConfigEditor.ts.vue';
   import VcsViewpointComponent, {
     gotoViewpointOptions,
-  } from './VcsViewpointComponent.vue';
+  } from './VcsViewpointComponent.ts.vue';
+  import type VcsUiApp from '../../vcsUiApp.js';
 
   /**
    * An editor component for viewpoints using AbstractConfigEditor and VcsViewpointComponent
-   * @vue-prop {() => import("@vcmap/core").ViewpointOptions} getConfig
-   * @vue-prop {(import("@vcmap/core").ViewpointOptions) => Promise<void>} setConfig
-   * @vue-prop {Array<(v:string)=>(boolean|string)>} nameRules - Optional rules for name input.
+   * @vue-prop nameRules Optional rules for name input.
    */
-  export default {
+  export default defineComponent({
     name: 'VcsViewpointEditor',
     components: {
       AbstractConfigEditor,
@@ -39,58 +40,58 @@
     },
     props: {
       getConfig: {
-        type: Function,
+        type: Function as PropType<() => ViewpointOptions>,
         required: true,
       },
       setConfig: {
-        type: Function,
+        type: Function as PropType<(config: ViewpointOptions) => Promise<void>>,
         required: true,
       },
       nameRules: {
-        type: Array,
+        type: Array as PropType<Array<(v: string) => boolean | string>>,
         default: () => [],
       },
     },
     emits: ['close'],
     setup(props, { emit }) {
-      const app = inject('vcsApp');
+      const app = inject('vcsApp') as VcsUiApp;
       const localConfig = ref(props.getConfig());
       const originalConfig = structuredClone(props.getConfig());
       let cancel = false;
 
-      async function gotoViewpoint() {
+      async function gotoViewpoint(): Promise<void> {
         await gotoViewpointOptions(app, localConfig.value);
       }
 
-      async function reset() {
+      async function reset(): Promise<void> {
         localConfig.value = props.getConfig();
         await gotoViewpoint();
       }
 
-      gotoViewpoint().catch((err) =>
-        getLogger('ViewpointEditor.vue').error(err),
-      );
+      gotoViewpoint().catch((err: unknown) => {
+        getLogger('ViewpointEditor.vue').error(String(err));
+      });
 
-      onUnmounted(() => {
+      onUnmounted(async () => {
         if (!cancel && !deepEqual(originalConfig, toRaw(localConfig.value))) {
-          props.setConfig(localConfig.value);
+          await props.setConfig(localConfig.value);
         }
       });
 
       return {
         localConfig,
-        apply() {
+        reset,
+        apply(): void {
           emit('close');
         },
-        async cancel() {
+        async cancel(): Promise<void> {
           await reset();
           cancel = true;
           emit('close');
         },
-        reset,
       };
     },
-  };
+  });
 </script>
 
 <style scoped></style>

package/src/components/viewpoint/VcsViewpointEditor.ts.vue.d.ts

@@ -0,0 +1,57 @@
+import type { PropType } from 'vue';
+import type { ViewpointOptions } from '@vcmap/core';
+/**
+ * An editor component for viewpoints using AbstractConfigEditor and VcsViewpointComponent
+ * @vue-prop nameRules Optional rules for name input.
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{
+    getConfig: {
+        type: PropType<() => ViewpointOptions>;
+        required: true;
+    };
+    setConfig: {
+        type: PropType<(config: ViewpointOptions) => Promise<void>>;
+        required: true;
+    };
+    nameRules: {
+        type: PropType<Array<(v: string) => boolean | string>>;
+        default: () => never[];
+    };
+}, {
+    localConfig: import("vue", { with: { "resolution-mode": "import" } }).Ref<{
+        type?: string | undefined;
+        name?: string | undefined;
+        properties?: Record<string, unknown> | undefined;
+        cameraPosition?: number[] | undefined;
+        groundPosition?: number[] | undefined;
+        distance?: number | undefined;
+        heading?: number | undefined;
+        pitch?: number | undefined;
+        roll?: number | undefined;
+        animate?: boolean | undefined;
+        duration?: number | undefined;
+        easingFunctionName?: string | undefined;
+    }>;
+    reset: () => Promise<void>;
+    apply(): void;
+    cancel(): Promise<void>;
+}, unknown, {}, {}, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, import("vue", { with: { "resolution-mode": "import" } }).ComponentOptionsMixin, "close"[], "close", import("vue", { with: { "resolution-mode": "import" } }).PublicProps, Readonly<import("vue", { with: { "resolution-mode": "import" } }).ExtractPropTypes<{
+    getConfig: {
+        type: PropType<() => ViewpointOptions>;
+        required: true;
+    };
+    setConfig: {
+        type: PropType<(config: ViewpointOptions) => Promise<void>>;
+        required: true;
+    };
+    nameRules: {
+        type: PropType<Array<(v: string) => boolean | string>>;
+        default: () => never[];
+    };
+}>> & {
+    onClose?: ((...args: any[]) => any) | undefined;
+}, {
+    nameRules: ((v: string) => boolean | string)[];
+}, {}>;

package/src/contentTree/LayerSwap.vue

@@ -26,8 +26,8 @@
     WMSLayer,
   } from '@vcmap/core';
   import { getLogger } from '@vcsuite/logger';
-  import VcsHelp from '../components/notification/VcsHelp.vue';
-  import VcsTreeview from '../components/lists/VcsTreeview.vue';
+  import VcsHelp from '../components/notification/VcsHelp.ts.vue';
+  import VcsTreeview from '../components/lists/VcsTreeview.ts.vue';
   import WMSGroupContentTreeItem from './wmsGroupContentTreeItem.js';
   import {
     moveItem,

package/src/contentTree/LayerSwap.vue.d.ts

@@ -1,6 +1,8 @@
 export const layerSwapId: "layer-swap-window";
-declare const _default: import("vue").DefineComponent<{}, {
-    items: import("vue").ShallowRef<({
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{}, {
+    items: import("vue", { with: { "resolution-mode": "import" } }).ShallowRef<({
         name: any;
         title: any;
         index: any;
@@ -35,7 +37,6 @@ declare const _default: import("vue").DefineComponent<{}, {
      * @param {import("../components/lists/dragHelper.js").ItemMovedEvent} event
      */
     move(event: import("../components/lists/dragHelper.js").ItemMovedEvent): void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
-export default _default;
+}, {}, {}, {}, 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<{}>>, {}, {}>;
 declare const wmsLayerName: unique symbol;
 import { vcsLayerName } from '@vcmap/core';

package/src/contentTree/LayerTree.vue

@@ -29,8 +29,8 @@
   import { inject, computed, onUnmounted } from 'vue';
   import { VSheet } from 'vuetify/components';
   import { useDisplay } from 'vuetify';
-  import VcsTreeview from '../components/lists/VcsTreeview.vue';
-  import VcsButton from '../components/buttons/VcsButton.vue';
+  import VcsTreeview from '../components/lists/VcsTreeview.ts.vue';
+  import VcsButton from '../components/buttons/VcsButton.ts.vue';
   import LayerSwap, { layerSwapId } from './LayerSwap.vue';
   import { createToggleAction } from '../actions/actionHelper.js';
   import { vcsAppSymbol } from '../pluginHelper.js';

package/src/contentTree/LayerTree.vue.d.ts

@@ -1,18 +1,19 @@
-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<{
     windowState: {
         type: ObjectConstructor;
         required: true;
     };
 }, {
     tree: any;
-    open: import("vue").WritableComputedRef<any>;
-    showAction: import("vue").ComputedRef<boolean>;
-    smAndUp: import("vue").Ref<boolean>;
+    open: import("vue", { with: { "resolution-mode": "import" } }).WritableComputedRef<any>;
+    showAction: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<boolean>;
+    smAndUp: import("vue", { with: { "resolution-mode": "import" } }).Ref<boolean>;
     action: import("../actions/actionHelper.js", { with: { "resolution-mode": "import" } }).VcsAction;
-}, 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<{
     windowState: {
         type: ObjectConstructor;
         required: true;
     };
 }>>, {}, {}>;
-export default _default;

package/src/contentTree/contentTreeCollection.d.ts

@@ -100,7 +100,7 @@ declare class ContentTreeCollection extends IndexedCollection<ContentTreeItem> {
      * Order of ids is dependent on their position in the collection and weight.
      * @type {Array<string>}
      */
-    get subTreeIds(): string[];
+    get subTreeIds(): Array<string>;
     /**
      * @param {string} id
      * @returns {import("vue").ComputedRef<Array<import("./contentTreeItem.js").TreeViewItem>>}

package/src/contentTree/contentTreeItem.d.ts

@@ -154,7 +154,7 @@ declare class ContentTreeItem {
     /**
      * @param {string} url
      */
-    set infoUrl(url: string | null);
+    set infoUrl(url: string);
     /**
      * @type {string|null}
      */
@@ -220,7 +220,7 @@ declare class ContentTreeItem {
      * A slice of the underlying actions array. Use add/removeAction to manipulate the actions array.
      * @type {Array<import("../actions/actionHelper.js").VcsAction>}
      */
-    get actions(): import("../actions/actionHelper.js").VcsAction[];
+    get actions(): Array<import("../actions/actionHelper.js").VcsAction>;
     /**
      * @param {boolean} visible
      */
@@ -248,11 +248,11 @@ declare class ContentTreeItem {
     /**
      * @param {StateActionState} state
      */
-    set state(state: number);
+    set state(state: StateActionState);
     /**
      * @type {StateActionState}
      */
-    get state(): number;
+    get state(): StateActionState;
     /**
      * @param {string|undefined} title
      */
@@ -272,7 +272,7 @@ declare class ContentTreeItem {
     /**
      * @param {(string|HTMLCanvasElement|HTMLImageElement)=} icon
      */
-    set icon(icon: string | HTMLCanvasElement | HTMLImageElement | undefined);
+    set icon(icon: (string | HTMLCanvasElement | HTMLImageElement) | undefined);
     /**
      * @type {string|HTMLCanvasElement|HTMLImageElement|undefined}
      */
@@ -306,7 +306,7 @@ declare class ContentTreeItem {
      * @param {import("../actions/actionHelper.js").VcsAction} action
      * @param {number} [weight=11]
      */
-    addAction(action: import("../actions/actionHelper.js").VcsAction, weight?: number | undefined): void;
+    addAction(action: import("../actions/actionHelper.js").VcsAction, weight?: number): void;
     /**
      * @param {string} actionName
      */

package/src/contentTree/wmsChildContentTreeItem.js

@@ -6,7 +6,7 @@ import {
 } from '../actions/actionHelper.js';
 import { StateActionState } from '../actions/stateRefAction.js';
 import ContentTreeItem from './contentTreeItem.js';
-import VcsActionList from '../components/lists/VcsActionList.vue';
+import VcsActionList from '../components/lists/VcsActionList.ts.vue';
 import { vcsAppSymbol } from '../pluginHelper.js';
 
 /**

package/src/contentTree/wmsGroupContentTreeItem.d.ts

@@ -1,5 +1,5 @@
 export default WMSGroupContentTreeItem;
-export type WMSGroupContentTreeItemOptions = import('./contentTreeItem.js').ContentTreeItemOptions & {
+export type WMSGroupContentTreeItemOptions = import("./contentTreeItem.js").ContentTreeItemOptions & {
     layerName: string;
     loadOnStartup?: boolean;
     showWhenNotSupported?: boolean;
@@ -178,7 +178,7 @@ declare class WMSGroupContentTreeItem extends VcsObjectContentTreeItem<import(".
      * readonly access, do not manipulate the entries directly.
      * @type {Array<WMSEntry>}
      */
-    get wmsEntries(): WMSEntry[];
+    get wmsEntries(): Array<WMSEntry>;
     /**
      * @type {import("@vcmap/core").WMSLayer|undefined}
      * @private

package/src/featureInfo/AddressBalloonComponent.vue.d.ts

@@ -1,2 +1,3 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{}, {}, {}, {}, {}, 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<{}>>, {}, {}>;

package/src/featureInfo/BalloonComponent.vue

@@ -70,8 +70,8 @@
     VListItemTitle,
   } from 'vuetify/components';
   import { setupBalloonPositionListener } from './balloonHelper.js';
-  import VcsButton from '../components/buttons/VcsButton.vue';
-  import { getTag, getTagOptions } from '../components/tables/VcsTable.vue';
+  import VcsButton from '../components/buttons/VcsButton.ts.vue';
+  import { getTag, getTagOptions } from '../components/tables/VcsTable.ts.vue';
   import { useIconSize } from '../vuePlugins/vuetify.js';
 
   /**

package/src/featureInfo/BalloonComponent.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<{
     featureId: {
         type: StringConstructor;
         required: true;
@@ -24,11 +26,11 @@ declare const _default: import("vue").DefineComponent<{
         default: null;
     };
 }, {
-    iconSize: import("vue").ComputedRef<number>;
+    iconSize: import("vue", { with: { "resolution-mode": "import" } }).ComputedRef<number>;
     close: () => void;
     getTag: typeof getTag;
     getTagOptions: typeof getTagOptions;
-}, 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<{
     featureId: {
         type: StringConstructor;
         required: true;
@@ -57,6 +59,5 @@ declare const _default: import("vue").DefineComponent<{
     position: unknown[];
     tags: Record<string, any>;
 }, {}>;
-export default _default;
-import { getTag } from '../components/tables/VcsTable.vue';
-import { getTagOptions } from '../components/tables/VcsTable.vue';
+import { getTag } from '../components/tables/VcsTable.ts.vue';
+import { getTagOptions } from '../components/tables/VcsTable.ts.vue';

package/src/featureInfo/ClusterFeatureComponent.vue

@@ -1,15 +1,15 @@
 <script setup>
   import { ref, shallowRef, inject, onUnmounted, watch } from 'vue';
   import { LayerState } from '@vcmap/core';
-  import VcsGroupedList from '../components/lists/VcsGroupedList.vue';
+  import VcsGroupedList from '../components/lists/VcsGroupedList.ts.vue';
 
   const props = defineProps({
-    /** @type {import("../components/lists/VcsGroupedList.vue").VcsGroupedListItem} */
+    /** @type {import("../components/lists/VcsGroupedList.ts.vue").VcsGroupedListItem} */
     items: {
       type: Array,
       default: () => [],
     },
-    /** @type {import("../components/lists/VcsGroupedList.vue").VcsListGroup} */
+    /** @type {import("../components/lists/VcsGroupedList.ts.vue").VcsListGroup} */
     groups: {
       type: Array,
       default: () => [],

package/src/featureInfo/ClusterFeatureComponent.vue.d.ts

@@ -1,7 +1,3 @@
-declare const _default: import("vue").DefineComponent<{}, {
-    $emit: (event: "close", ...args: any[]) => void;
-    $props: {
-        readonly [x: string]: any;
-    };
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, import("vue", { with: { "resolution-mode": "import" } }).PublicProps>;

package/src/featureInfo/IframeComponent.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<{
     src: {
         type: StringConstructor;
         required: true;
@@ -14,7 +16,7 @@ declare const _default: import("vue").DefineComponent<{
         type: ObjectConstructor;
         default: () => void;
     };
-}, any, any, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, any, 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<{
     src: {
         type: StringConstructor;
         required: true;
@@ -34,4 +36,3 @@ declare const _default: import("vue").DefineComponent<{
     title: string;
     attributes: Record<string, any>;
 }, {}>;
-export default _default;

package/src/featureInfo/MarkdownBalloonComponent.vue.d.ts

@@ -1,2 +1,3 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: import("vue", { with: { "resolution-mode": "import" } }).DefineComponent<{}, {}, {}, {}, {}, 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<{}>>, {}, {}>;

package/src/featureInfo/abstractFeatureInfoView.d.ts

@@ -115,7 +115,7 @@ export type FeatureInfoViewOptions = import("@vcmap/core").VcsObjectOptions & {
     mergeParentAttributes?: boolean;
     removeNoDataAttributes?: boolean;
     tags?: Record<string, HTMLTagOptions>;
-    window?: Pick<import("../manager/window/windowManager.js").WindowComponentOptions, 'state' | 'slot' | 'position'>;
+    window?: Pick<import("../manager/window/windowManager.js").WindowComponentOptions, "state" | "slot" | "position">;
 };
 /**
  * Abstract class to be extended by FeatureInfoView classes
@@ -178,12 +178,12 @@ declare class AbstractFeatureInfoView extends VcsObject {
      * window options, configured in a module, used only internally by AbstractFeatureInfoView or subclass
      * @type {Pick<import("../manager/window/windowManager.js").WindowComponentOptions<FeatureInfoProps>,'state'|'slot'|'position'>|Object}
      */
-    get window(): Object | Pick<import("../manager/window/windowManager.js").WindowComponentOptions<FeatureInfoProps>, "slot" | "state" | "position">;
+    get window(): Pick<import("../manager/window/windowManager.js").WindowComponentOptions<FeatureInfoProps>, "state" | "slot" | "position"> | Object;
     /**
      * component provided by a FeatureInfoView class, passed to featureInfo via `getWindowComponentOptions()`
      * @type {import("vue").Component<FeatureInfoProps, unknown, unknown>|undefined}
      */
-    get component(): import("vue").Component<FeatureInfoProps, unknown, unknown, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any> | undefined;
+    get component(): import("vue").Component<FeatureInfoProps, unknown, unknown> | undefined;
     /**
      * @param {undefined|import("ol").Feature|import("@vcmap-cesium/engine").Cesium3DTileFeature|import("@vcmap-cesium/engine").Cesium3DTilePointFeature} feature
      * @returns {Object}

package/src/featureInfo/abstractFeatureInfoView.js

@@ -1,7 +1,7 @@
 import { parseBoolean } from '@vcsuite/parsers';
 import { renderTemplate, VcsObject } from '@vcmap/core';
 import { WindowSlot } from '../manager/window/windowManager.js';
-import { defaultTagOptions } from '../components/tables/VcsTable.vue';
+import { defaultTagOptions } from '../components/tables/VcsTable.ts.vue';
 
 /**
  * @typedef {Object} FeatureInfoProps

package/src/featureInfo/balloonFeatureInfoView.d.ts

@@ -5,7 +5,7 @@
  * @param {string|null} [defaultValue]
  * @returns {string|null}
  */
-export function extractNestedKey(key: string, attrs: Object, defaultValue?: string | null | undefined): string | null;
+export function extractNestedKey(key: string, attrs: Object, defaultValue?: string | null): string | null;
 export default BalloonFeatureInfoView;
 export type BalloonFeatureInfoViewOptions = import("./abstractFeatureInfoView.js").FeatureInfoViewOptions & {
     balloonTitle?: string;
@@ -44,7 +44,7 @@ declare class BalloonFeatureInfoView extends AbstractFeatureInfoView {
      * @param {BalloonFeatureInfoViewOptions} options
      * @param {import("vue").Component<BalloonFeatureInfoViewProps, unknown, unknown>} [component=BalloonComponent]
      */
-    constructor(options: BalloonFeatureInfoViewOptions, component?: import("vue").Component<BalloonFeatureInfoViewProps, unknown, unknown, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any> | undefined);
+    constructor(options: BalloonFeatureInfoViewOptions, component?: import("vue").Component<BalloonFeatureInfoViewProps, unknown, unknown>);
     /**
      * @type {string}
      */