@nuxt/scripts 1.3.5 → 2.0.0-beta.1

package/dist/runtime/components/Leaflet/ScriptLeafletPopup.d.vue.ts

@@ -0,0 +1,31 @@
+import type * as Leaflet from 'leaflet';
+type __VLS_Props = {
+    /** Position for a standalone popup. Omit when nested inside a marker. */
+    position?: Leaflet.LatLngExpression;
+    /** Whether the popup is open. @default false */
+    open?: boolean;
+    /** Options passed to `L.popup`. */
+    options?: Leaflet.PopupOptions;
+};
+type __VLS_Slots = {
+    default?: () => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    popup: import("vue").ShallowRef<Leaflet.Popup | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (event: Leaflet.LeafletEvent) => any;
+    open: (event: Leaflet.LeafletEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: ((event: Leaflet.LeafletEvent) => any) | undefined;
+    onOpen?: ((event: Leaflet.LeafletEvent) => any) | undefined;
+}>, {
+    open: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Leaflet/ScriptLeafletPopup.vue

@@ -0,0 +1,81 @@
+<script setup>
+import { inject, useTemplateRef, watch } from "vue";
+import { LEAFLET_MARKER_INJECTION_KEY, useLeafletResource } from "./useLeafletResource";
+const props = defineProps({
+  position: { type: null, required: false },
+  open: { type: Boolean, required: false, default: false },
+  options: { type: null, required: false }
+});
+const emit = defineEmits(["open", "close"]);
+defineSlots();
+const markerContext = inject(LEAFLET_MARKER_INJECTION_KEY, void 0);
+const content = useTemplateRef("content");
+let boundMarker;
+let popupMap;
+const popup = useLeafletResource({
+  ready: () => !!content.value && (!!markerContext?.marker.value || !!props.position),
+  create({ leaflet, map }) {
+    popupMap = map;
+    const instance = leaflet.popup(props.options).setContent(content.value);
+    instance.on("add", (event) => emit("open", event));
+    instance.on("remove", (event) => emit("close", event));
+    boundMarker = markerContext?.marker.value;
+    if (boundMarker) {
+      boundMarker.bindPopup(instance);
+      if (props.open)
+        boundMarker.openPopup();
+    } else if (props.position) {
+      instance.setLatLng(props.position);
+      if (props.open)
+        instance.openOn(map);
+    }
+    return instance;
+  },
+  cleanup(instance) {
+    if (boundMarker) {
+      boundMarker.unbindPopup();
+      boundMarker = void 0;
+    }
+    instance.off();
+    instance.remove();
+    popupMap = void 0;
+  }
+});
+watch(() => props.open, (open) => {
+  if (!popup.value)
+    return;
+  if (boundMarker) {
+    if (open)
+      boundMarker.openPopup();
+    else
+      boundMarker.closePopup();
+  } else if (open && popupMap) {
+    popup.value.openOn(popupMap);
+  } else {
+    popup.value.close();
+  }
+});
+watch(() => props.position, (position) => {
+  if (popup.value && position && !boundMarker)
+    popup.value.setLatLng(position);
+}, { deep: 1 });
+watch(() => props.options, (options) => {
+  if (!popup.value || !options)
+    return;
+  Object.assign(popup.value.options, options);
+  popup.value.update();
+}, { deep: 2 });
+defineExpose({ popup });
+</script>
+
+<template>
+  <div class="leaflet-popup-content-source">
+    <div ref="content">
+      <slot />
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.leaflet-popup-content-source{display:none}
+</style>

package/dist/runtime/components/Leaflet/ScriptLeafletPopup.vue.d.ts

@@ -0,0 +1,31 @@
+import type * as Leaflet from 'leaflet';
+type __VLS_Props = {
+    /** Position for a standalone popup. Omit when nested inside a marker. */
+    position?: Leaflet.LatLngExpression;
+    /** Whether the popup is open. @default false */
+    open?: boolean;
+    /** Options passed to `L.popup`. */
+    options?: Leaflet.PopupOptions;
+};
+type __VLS_Slots = {
+    default?: () => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    popup: import("vue").ShallowRef<Leaflet.Popup | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (event: Leaflet.LeafletEvent) => any;
+    open: (event: Leaflet.LeafletEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: ((event: Leaflet.LeafletEvent) => any) | undefined;
+    onOpen?: ((event: Leaflet.LeafletEvent) => any) | undefined;
+}>, {
+    open: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Leaflet/ScriptLeafletTileLayer.d.vue.ts

@@ -0,0 +1,26 @@
+import type * as Leaflet from 'leaflet';
+type __VLS_Props = {
+    /** Tile URL template, for example `https://tile.openstreetmap.org/{z}/{x}/{y}.png`. */
+    url: string;
+    /** Tile layer options. Include the provider's required `attribution`. */
+    options?: Leaflet.TileLayerOptions;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    tileLayer: import("vue").ShallowRef<Leaflet.TileLayer | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    load: (event: Leaflet.LeafletEvent) => any;
+    loading: (event: Leaflet.LeafletEvent) => any;
+    tileerror: (event: Leaflet.TileErrorEvent) => any;
+    tileloadstart: (event: Leaflet.TileEvent) => any;
+    tileload: (event: Leaflet.TileEvent) => any;
+    tileabort: (event: Leaflet.TileEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onLoad?: ((event: Leaflet.LeafletEvent) => any) | undefined;
+    onLoading?: ((event: Leaflet.LeafletEvent) => any) | undefined;
+    onTileerror?: ((event: Leaflet.TileErrorEvent) => any) | undefined;
+    onTileloadstart?: ((event: Leaflet.TileEvent) => any) | undefined;
+    onTileload?: ((event: Leaflet.TileEvent) => any) | undefined;
+    onTileabort?: ((event: Leaflet.TileEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/Leaflet/ScriptLeafletTileLayer.vue

@@ -0,0 +1,38 @@
+<script setup>
+import { inject, watch } from "vue";
+import { bindLeafletEvents, LEAFLET_MAP_INJECTION_KEY, useLeafletResource } from "./useLeafletResource";
+const props = defineProps({
+  url: { type: String, required: true },
+  options: { type: null, required: false }
+});
+const emit = defineEmits(["loading", "load", "tileloadstart", "tileload", "tileabort", "tileerror"]);
+const mapContext = inject(LEAFLET_MAP_INJECTION_KEY, void 0);
+const tileEvents = ["loading", "load", "tileloadstart", "tileload", "tileabort", "tileerror"];
+const tileLayer = useLeafletResource({
+  create({ leaflet, map }) {
+    const layer = leaflet.tileLayer(props.url, props.options);
+    bindLeafletEvents(layer, emit, tileEvents);
+    return layer.addTo(map);
+  },
+  cleanup(layer) {
+    layer.off();
+    layer.remove();
+  }
+});
+watch(() => props.url, (url) => tileLayer.value?.setUrl(url));
+watch(() => props.options, (options) => {
+  if (!tileLayer.value || !mapContext?.leaflet.value || !options)
+    return;
+  mapContext.leaflet.value.Util.setOptions(tileLayer.value, options);
+  if (options.opacity !== void 0)
+    tileLayer.value.setOpacity(options.opacity);
+  if (options.zIndex !== void 0)
+    tileLayer.value.setZIndex(options.zIndex);
+  tileLayer.value.redraw();
+}, { deep: 2 });
+defineExpose({ tileLayer });
+</script>
+
+<template>
+  <!-- nuxt-scripts: Leaflet tile layer -->
+</template>

package/dist/runtime/components/Leaflet/ScriptLeafletTileLayer.vue.d.ts

@@ -0,0 +1,26 @@
+import type * as Leaflet from 'leaflet';
+type __VLS_Props = {
+    /** Tile URL template, for example `https://tile.openstreetmap.org/{z}/{x}/{y}.png`. */
+    url: string;
+    /** Tile layer options. Include the provider's required `attribution`. */
+    options?: Leaflet.TileLayerOptions;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    tileLayer: import("vue").ShallowRef<Leaflet.TileLayer | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    load: (event: Leaflet.LeafletEvent) => any;
+    loading: (event: Leaflet.LeafletEvent) => any;
+    tileerror: (event: Leaflet.TileErrorEvent) => any;
+    tileloadstart: (event: Leaflet.TileEvent) => any;
+    tileload: (event: Leaflet.TileEvent) => any;
+    tileabort: (event: Leaflet.TileEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onLoad?: ((event: Leaflet.LeafletEvent) => any) | undefined;
+    onLoading?: ((event: Leaflet.LeafletEvent) => any) | undefined;
+    onTileerror?: ((event: Leaflet.TileErrorEvent) => any) | undefined;
+    onTileloadstart?: ((event: Leaflet.TileEvent) => any) | undefined;
+    onTileload?: ((event: Leaflet.TileEvent) => any) | undefined;
+    onTileabort?: ((event: Leaflet.TileEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/Leaflet/useLeafletResource.d.ts

@@ -0,0 +1,30 @@
+import type * as Leaflet from 'leaflet';
+import type { InjectionKey, ShallowRef } from 'vue';
+export type LeafletNamespace = typeof Leaflet;
+export interface LeafletMapContext {
+    map: ShallowRef<Leaflet.Map | undefined>;
+    leaflet: ShallowRef<LeafletNamespace | undefined>;
+}
+export declare const LEAFLET_MAP_INJECTION_KEY: InjectionKey<LeafletMapContext>;
+export declare const LEAFLET_MARKER_INJECTION_KEY: InjectionKey<{
+    marker: ShallowRef<Leaflet.Marker | undefined>;
+}>;
+export interface LeafletResourceContext {
+    map: Leaflet.Map;
+    leaflet: LeafletNamespace;
+}
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer I) => void ? I : never;
+type LeafletEmit<TEvents extends object> = UnionToIntersection<{
+    [TEvent in keyof TEvents]: TEvents[TEvent] extends unknown[] ? (event: TEvent, ...args: TEvents[TEvent]) => void : never;
+}[keyof TEvents]>;
+export declare function bindLeafletEvents<TEvents extends object>(target: Leaflet.Evented, emit: LeafletEmit<TEvents>, events: readonly (keyof TEvents & string)[]): void;
+/**
+ * Creates a Leaflet resource once its parent map and any component-specific
+ * DOM refs are ready, then removes it synchronously during unmount.
+ */
+export declare function useLeafletResource<T>({ ready, create, cleanup, }: {
+    ready?: () => boolean;
+    create: (context: LeafletResourceContext) => T;
+    cleanup: (resource: T, context: LeafletResourceContext) => void;
+}): ShallowRef<T | undefined>;
+export {};

package/dist/runtime/components/Leaflet/useLeafletResource.js

@@ -0,0 +1,46 @@
+import { inject, onUnmounted, shallowRef, watch } from "vue";
+export const LEAFLET_MAP_INJECTION_KEY = Symbol("leaflet-map");
+export const LEAFLET_MARKER_INJECTION_KEY = Symbol("leaflet-marker");
+export function bindLeafletEvents(target, emit, events) {
+  const emitEvent = emit;
+  for (const event of events)
+    target.on(event, (payload) => emitEvent(event, payload));
+}
+export function useLeafletResource({
+  ready,
+  create,
+  cleanup
+}) {
+  const mapContext = inject(LEAFLET_MAP_INJECTION_KEY, void 0);
+  const resource = shallowRef();
+  let creating = false;
+  let resourceContext;
+  if (import.meta.dev && !mapContext) {
+    console.warn("[nuxt-scripts] Leaflet child components must be placed inside <ScriptLeafletMap>.");
+  }
+  const stop = watch(
+    () => [mapContext?.map.value, mapContext?.leaflet.value, ready?.() ?? true],
+    ([map, leaflet, isReady]) => {
+      if (!map || !leaflet || !isReady || resource.value || creating)
+        return;
+      creating = true;
+      try {
+        resourceContext = { map, leaflet };
+        resource.value = create(resourceContext);
+      } catch (error) {
+        console.error("[nuxt-scripts] Leaflet resource creation failed:", error);
+      } finally {
+        creating = false;
+      }
+    },
+    { immediate: true }
+  );
+  onUnmounted(() => {
+    stop();
+    if (resource.value && resourceContext)
+      cleanup(resource.value, resourceContext);
+    resource.value = void 0;
+    resourceContext = void 0;
+  });
+  return resource;
+}

package/dist/runtime/components/MapLibre/ScriptMapLibreGeoJson.d.vue.ts

@@ -0,0 +1,39 @@
+import type { GeoJSON } from 'geojson';
+import type * as MapLibreGl from 'maplibre-gl';
+import type * as MapLibre from 'maplibre-gl';
+export type ScriptMapLibreGeoJsonLayer = Omit<MapLibre.LayerSpecification, 'source'> & {
+    /** Override the component's source ID for this layer. */
+    source?: string;
+};
+export interface ScriptMapLibreGeoJsonResource {
+    map: MapLibre.Map;
+    onLoad: () => void;
+    onStyleLoad: () => void;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    /** MapLibre source ID. Changing it rebuilds the owned source and layers. */
+    sourceId: string;
+    /** Inline GeoJSON data or a URL returning GeoJSON. */
+    data: GeoJSON | string;
+    /** GeoJSON source options. `type` and `data` are supplied by the component. */
+    sourceOptions?: Omit<MapLibreGl.GeoJSONSourceSpecification, "type" | "data">;
+    /** Style layers backed by this source. */
+    layers: ScriptMapLibreGeoJsonLayer[];
+    /** Existing layer ID before which the layers are inserted. */
+    beforeId?: string;
+}, {
+    geoJson: import("vue").ShallowRef<ScriptMapLibreGeoJsonResource | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    /** MapLibre source ID. Changing it rebuilds the owned source and layers. */
+    sourceId: string;
+    /** Inline GeoJSON data or a URL returning GeoJSON. */
+    data: GeoJSON | string;
+    /** GeoJSON source options. `type` and `data` are supplied by the component. */
+    sourceOptions?: Omit<MapLibreGl.GeoJSONSourceSpecification, "type" | "data">;
+    /** Style layers backed by this source. */
+    layers: ScriptMapLibreGeoJsonLayer[];
+    /** Existing layer ID before which the layers are inserted. */
+    beforeId?: string;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/MapLibre/ScriptMapLibreGeoJson.vue

@@ -0,0 +1,84 @@
+<script>
+
+</script>
+
+<script setup>
+import { toRaw, watch } from "vue";
+import { useMapLibreResource } from "./useMapLibreResource";
+const props = defineProps({
+  sourceId: { type: String, required: true },
+  data: { type: null, required: true },
+  sourceOptions: { type: Object, required: false },
+  layers: { type: Array, required: true },
+  beforeId: { type: String, required: false }
+});
+let ownedLayerIds = [];
+let ownedSourceId;
+function removeOwnedResources(map) {
+  for (const layerId of [...ownedLayerIds].reverse()) {
+    if (map.getLayer(layerId))
+      map.removeLayer(layerId);
+  }
+  ownedLayerIds = [];
+  if (ownedSourceId && map.getSource(ownedSourceId))
+    map.removeSource(ownedSourceId);
+  ownedSourceId = void 0;
+}
+function syncResources(map) {
+  if (!map.isStyleLoaded())
+    return;
+  removeOwnedResources(map);
+  const sourceId = props.sourceId;
+  try {
+    map.addSource(sourceId, {
+      ...toRaw(props.sourceOptions),
+      type: "geojson",
+      data: toRaw(props.data)
+    });
+    ownedSourceId = sourceId;
+    for (const layer of props.layers) {
+      const nextLayer = {
+        ...toRaw(layer),
+        source: layer.source || sourceId
+      };
+      map.addLayer(nextLayer, props.beforeId);
+      ownedLayerIds.push(nextLayer.id);
+    }
+  } catch (error) {
+    removeOwnedResources(map);
+    throw error;
+  }
+}
+const geoJson = useMapLibreResource({
+  create({ map }) {
+    const onStyleLoad = () => syncResources(map);
+    const onLoad = () => {
+      if (!ownedSourceId)
+        syncResources(map);
+    };
+    map.on("style.load", onStyleLoad);
+    map.on("load", onLoad);
+    syncResources(map);
+    return { map, onLoad, onStyleLoad };
+  },
+  cleanup(resource) {
+    resource.map.off("load", resource.onLoad);
+    resource.map.off("style.load", resource.onStyleLoad);
+    removeOwnedResources(resource.map);
+  }
+});
+watch(() => props.data, (data) => {
+  const source = geoJson.value?.map.getSource(props.sourceId);
+  if (source?.type === "geojson")
+    source.setData(toRaw(data));
+}, { deep: 2 });
+watch(() => [props.sourceId, props.layers, props.sourceOptions, props.beforeId], () => {
+  if (geoJson.value)
+    syncResources(geoJson.value.map);
+}, { deep: 3 });
+defineExpose({ geoJson });
+</script>
+
+<template>
+  <!-- nuxt-scripts: MapLibre GeoJSON source and layers -->
+</template>

package/dist/runtime/components/MapLibre/ScriptMapLibreGeoJson.vue.d.ts

@@ -0,0 +1,39 @@
+import type { GeoJSON } from 'geojson';
+import type * as MapLibreGl from 'maplibre-gl';
+import type * as MapLibre from 'maplibre-gl';
+export type ScriptMapLibreGeoJsonLayer = Omit<MapLibre.LayerSpecification, 'source'> & {
+    /** Override the component's source ID for this layer. */
+    source?: string;
+};
+export interface ScriptMapLibreGeoJsonResource {
+    map: MapLibre.Map;
+    onLoad: () => void;
+    onStyleLoad: () => void;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    /** MapLibre source ID. Changing it rebuilds the owned source and layers. */
+    sourceId: string;
+    /** Inline GeoJSON data or a URL returning GeoJSON. */
+    data: GeoJSON | string;
+    /** GeoJSON source options. `type` and `data` are supplied by the component. */
+    sourceOptions?: Omit<MapLibreGl.GeoJSONSourceSpecification, "type" | "data">;
+    /** Style layers backed by this source. */
+    layers: ScriptMapLibreGeoJsonLayer[];
+    /** Existing layer ID before which the layers are inserted. */
+    beforeId?: string;
+}, {
+    geoJson: import("vue").ShallowRef<ScriptMapLibreGeoJsonResource | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    /** MapLibre source ID. Changing it rebuilds the owned source and layers. */
+    sourceId: string;
+    /** Inline GeoJSON data or a URL returning GeoJSON. */
+    data: GeoJSON | string;
+    /** GeoJSON source options. `type` and `data` are supplied by the component. */
+    sourceOptions?: Omit<MapLibreGl.GeoJSONSourceSpecification, "type" | "data">;
+    /** Style layers backed by this source. */
+    layers: ScriptMapLibreGeoJsonLayer[];
+    /** Existing layer ID before which the layers are inserted. */
+    beforeId?: string;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/MapLibre/ScriptMapLibreMap.d.vue.ts

@@ -0,0 +1,122 @@
+import type * as MapLibre from 'maplibre-gl';
+import type { HTMLAttributes, ReservedProps, ShallowRef } from 'vue';
+import type { ElementScriptTrigger } from '#nuxt-scripts/types';
+export { MAPLIBRE_MAP_INJECTION_KEY } from './useMapLibreResource.js';
+export interface ScriptMapLibreMapProps {
+    /**
+     * Defines when the MapLibre script loads.
+     * @default 'visible'
+     */
+    trigger?: ElementScriptTrigger;
+    /** MapLibre style URL or inline style specification. */
+    mapStyle: string | MapLibre.StyleSpecification;
+    /** Initial and reactively controlled map center. */
+    center: MapLibre.LngLatLike;
+    /** Initial and reactively controlled zoom level. @default 12 */
+    zoom?: number;
+    /** Initial and reactively controlled bearing in degrees. @default 0 */
+    bearing?: number;
+    /** Initial and reactively controlled pitch in degrees. @default 0 */
+    pitch?: number;
+    /** Options passed to `new maplibregl.Map()`. Dedicated props take precedence. */
+    options?: Omit<MapLibre.MapOptions, 'container'>;
+    /** Inject MapLibre's stylesheet when the script begins loading. @default true */
+    injectStyles?: boolean;
+    /** Custom MapLibre stylesheet URL. */
+    stylesheetUrl?: string;
+    /** Worker URL used with MapLibre's CSP-compatible build. */
+    workerUrl?: string;
+    /** Width reserved before the map loads. @default 640 */
+    width?: number | string;
+    /** Height reserved before the map loads. @default 400 */
+    height?: number | string;
+    /** Accessible name for an interactive map. @default 'Interactive map' */
+    ariaLabel?: string;
+    /** Disable map input and remove it from the accessibility tree when decorative. @default true */
+    interactive?: boolean;
+    /** Attributes applied to the outer layout container. */
+    rootAttrs?: HTMLAttributes & ReservedProps & Record<string, unknown>;
+}
+export interface ScriptMapLibreMapExpose {
+    maplibre: ShallowRef<typeof MapLibre | undefined>;
+    map: ShallowRef<MapLibre.Map | undefined>;
+    load: () => Promise<unknown> | unknown;
+}
+export interface ScriptMapLibreMapEmits {
+    'ready': [payload: ScriptMapLibreMapExpose];
+    'error': [error: Error];
+    'click': [event: MapLibre.MapEventType['click']];
+    'move': [event: MapLibre.MapEventType['move']];
+    'moveend': [event: MapLibre.MapEventType['moveend']];
+    'zoom': [event: MapLibre.MapEventType['zoom']];
+    'zoomend': [event: MapLibre.MapEventType['zoomend']];
+    'rotate': [event: MapLibre.MapEventType['rotate']];
+    'rotateend': [event: MapLibre.MapEventType['rotateend']];
+    'pitch': [event: MapLibre.MapEventType['pitch']];
+    'pitchend': [event: MapLibre.MapEventType['pitchend']];
+    'update:center': [center: MapLibre.LngLat];
+    'update:zoom': [zoom: number];
+    'update:bearing': [bearing: number];
+    'update:pitch': [pitch: number];
+}
+export interface ScriptMapLibreMapSlots {
+    default?: () => any;
+    loading?: () => any;
+    awaitingLoad?: () => any;
+    error?: (props: {
+        error: Error;
+    }) => any;
+    placeholder?: () => any;
+    /** Text or links that expose the canvas map's essential information to assistive technology. */
+    description?: () => any;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ScriptMapLibreMapProps, ScriptMapLibreMapExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    error: (error: Error) => any;
+    ready: (payload: ScriptMapLibreMapExpose) => any;
+    click: (event: MapLibre.MapMouseEvent) => any;
+    move: (event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | WheelEvent | undefined>) => any;
+    zoom: (event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | WheelEvent | undefined>) => any;
+    zoomend: (event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | WheelEvent | undefined>) => any;
+    moveend: (event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | WheelEvent | undefined>) => any;
+    "update:center": (center: MapLibre.LngLat) => any;
+    "update:zoom": (zoom: number) => any;
+    rotate: (event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | undefined>) => any;
+    rotateend: (event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | undefined>) => any;
+    pitch: (event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | undefined>) => any;
+    pitchend: (event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | undefined>) => any;
+    "update:bearing": (bearing: number) => any;
+    "update:pitch": (pitch: number) => any;
+}, string, import("vue").PublicProps, Readonly<ScriptMapLibreMapProps> & Readonly<{
+    onError?: ((error: Error) => any) | undefined;
+    onReady?: ((payload: ScriptMapLibreMapExpose) => any) | undefined;
+    onClick?: ((event: MapLibre.MapMouseEvent) => any) | undefined;
+    onMove?: ((event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | WheelEvent | undefined>) => any) | undefined;
+    onZoom?: ((event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | WheelEvent | undefined>) => any) | undefined;
+    onZoomend?: ((event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | WheelEvent | undefined>) => any) | undefined;
+    onMoveend?: ((event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | WheelEvent | undefined>) => any) | undefined;
+    "onUpdate:center"?: ((center: MapLibre.LngLat) => any) | undefined;
+    "onUpdate:zoom"?: ((zoom: number) => any) | undefined;
+    onRotate?: ((event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | undefined>) => any) | undefined;
+    onRotateend?: ((event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | undefined>) => any) | undefined;
+    onPitch?: ((event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | undefined>) => any) | undefined;
+    onPitchend?: ((event: MapLibre.MapLibreEvent<MouseEvent | TouchEvent | undefined>) => any) | undefined;
+    "onUpdate:bearing"?: ((bearing: number) => any) | undefined;
+    "onUpdate:pitch"?: ((pitch: number) => any) | undefined;
+}>, {
+    injectStyles: boolean;
+    trigger: ElementScriptTrigger;
+    width: number | string;
+    height: number | string;
+    zoom: number;
+    ariaLabel: string;
+    interactive: boolean;
+    pitch: number;
+    bearing: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ScriptMapLibreMapSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};