@maptiler/geocoding-control 3.0.0-rc.4 → 3.0.0-rc.5

package/dist/src/controls/leaflet-events.d.ts

@@ -1,42 +1,71 @@
-import { Marker } from 'leaflet';
+import { LeafletEvent, Marker } from 'leaflet';
+import { MaptilerGeocoderEvent } from '../geocoder/geocoder-events';
 import { Feature } from '../types';
-import type * as Geocoder from "../geocoder/geocoder-events";
-export type ReverseToggleEvent = Geocoder.ReverseToggleEvent["detail"];
-export type QueryChangeEvent = Geocoder.QueryChangeEvent["detail"];
-export type FeaturesListedEvent = Geocoder.FeaturesListedEvent["detail"];
-export type RequestEvent = Geocoder.RequestEvent["detail"];
-export type ResponseEvent = Geocoder.ResponseEvent["detail"];
-export type SelectEvent = Geocoder.SelectEvent["detail"];
-export type PickEvent = Geocoder.PickEvent["detail"];
-export type MarkerClickEvent = {
-    feature: Feature;
-    marker: Marker;
-};
-export type MarkerMouseEnterEvent = {
-    feature: Feature;
-    marker: Marker;
-};
-export type MarkerMouseLeaveEvent = {
-    feature: Feature;
-    marker: Marker;
+import { LeafletGeocodingControl } from './leaflet-control';
+type BaseEvent = Pick<LeafletEvent, "type" | "target"> & {
+    target: LeafletGeocodingControl;
 };
+export declare namespace LeafletGeocodingControlEvent {
+    type ReverseToggleEvent = BaseEvent & MaptilerGeocoderEvent.ReverseToggleEvent["detail"];
+    type QueryChangeEvent = BaseEvent & MaptilerGeocoderEvent.QueryChangeEvent["detail"];
+    type QueryClearEvent = BaseEvent;
+    type RequestEvent = BaseEvent & MaptilerGeocoderEvent.RequestEvent["detail"];
+    type ResponseEvent = BaseEvent & MaptilerGeocoderEvent.ResponseEvent["detail"];
+    type SelectEvent = BaseEvent & MaptilerGeocoderEvent.SelectEvent["detail"];
+    type PickEvent = BaseEvent & MaptilerGeocoderEvent.PickEvent["detail"];
+    type FeaturesShowEvent = BaseEvent;
+    type FeaturesHideEvent = BaseEvent;
+    type FeaturesListedEvent = BaseEvent & MaptilerGeocoderEvent.FeaturesListedEvent["detail"];
+    type FeaturesClearEvent = BaseEvent;
+    type FocusInEvent = BaseEvent;
+    type FocusOutEvent = BaseEvent;
+    type MarkerClickEvent = BaseEvent & {
+        feature: Feature;
+        marker: Marker;
+    };
+    type MarkerMouseEnterEvent = BaseEvent & {
+        feature: Feature;
+        marker: Marker;
+    };
+    type MarkerMouseLeaveEvent = BaseEvent & {
+        feature: Feature;
+        marker: Marker;
+    };
+}
+export type ReverseToggleEvent = LeafletGeocodingControlEvent.ReverseToggleEvent;
+export type QueryChangeEvent = LeafletGeocodingControlEvent.QueryChangeEvent;
+export type QueryClearEvent = LeafletGeocodingControlEvent.QueryClearEvent;
+export type RequestEvent = LeafletGeocodingControlEvent.RequestEvent;
+export type ResponseEvent = LeafletGeocodingControlEvent.ResponseEvent;
+export type SelectEvent = LeafletGeocodingControlEvent.SelectEvent;
+export type PickEvent = LeafletGeocodingControlEvent.PickEvent;
+export type FeaturesShowEvent = LeafletGeocodingControlEvent.FeaturesShowEvent;
+export type FeaturesHideEvent = LeafletGeocodingControlEvent.FeaturesHideEvent;
+export type FeaturesListedEvent = LeafletGeocodingControlEvent.FeaturesListedEvent;
+export type FeaturesClearEvent = LeafletGeocodingControlEvent.FeaturesClearEvent;
+export type FocusInEvent = LeafletGeocodingControlEvent.FocusInEvent;
+export type FocusOutEvent = LeafletGeocodingControlEvent.FocusOutEvent;
+export type MarkerClickEvent = LeafletGeocodingControlEvent.MarkerClickEvent;
+export type MarkerMouseEnterEvent = LeafletGeocodingControlEvent.MarkerMouseEnterEvent;
+export type MarkerMouseLeaveEvent = LeafletGeocodingControlEvent.MarkerMouseLeaveEvent;
 export type LeafletGeocodingControlEventNameMap = {
     reversetoggle: ReverseToggleEvent;
     querychange: QueryChangeEvent;
-    queryclear: never;
+    queryclear: QueryClearEvent;
     request: RequestEvent;
     response: ResponseEvent;
     select: SelectEvent;
     pick: PickEvent;
-    featuresshow: never;
-    featureshide: never;
+    featuresshow: FeaturesShowEvent;
+    featureshide: FeaturesHideEvent;
     featureslisted: FeaturesListedEvent;
-    featuresclear: never;
-    focusin: never;
-    focusout: never;
+    featuresclear: FeaturesClearEvent;
+    focusin: FocusInEvent;
+    focusout: FocusOutEvent;
     markerclick: MarkerClickEvent;
     markermouseenter: MarkerMouseEnterEvent;
     markermouseleave: MarkerMouseLeaveEvent;
 };
 export type LeafletGeocodingControlEvent = LeafletGeocodingControlEventNameMap[keyof LeafletGeocodingControlEventNameMap];
 export type LeafletGeocodingControlEventName = keyof LeafletGeocodingControlEventNameMap;
+export {};

package/dist/src/controls/maplibregl-events.d.ts

@@ -1,40 +1,69 @@
 import { default as maplibregl } from 'maplibre-gl';
+import { MaptilerGeocoderEvent } from '../geocoder/geocoder-events';
 import { Feature } from '../types';
+import { MaplibreglGeocodingControl } from './maplibregl-control';
 type Marker = maplibregl.Marker;
-import type * as Geocoder from "../geocoder/geocoder-events";
-export type ReverseToggleEvent = Geocoder.ReverseToggleEvent["detail"];
-export type QueryChangeEvent = Geocoder.QueryChangeEvent["detail"];
-export type FeaturesListedEvent = Geocoder.FeaturesListedEvent["detail"];
-export type RequestEvent = Geocoder.RequestEvent["detail"];
-export type ResponseEvent = Geocoder.ResponseEvent["detail"];
-export type SelectEvent = Geocoder.SelectEvent["detail"];
-export type PickEvent = Geocoder.PickEvent["detail"];
-export type MarkerClickEvent = {
-    feature: Feature;
-    marker: Marker;
-};
-export type MarkerMouseEnterEvent = {
-    feature: Feature;
-    marker: Marker;
-};
-export type MarkerMouseLeaveEvent = {
-    feature: Feature;
-    marker: Marker;
+type MLEvent = Extract<Parameters<maplibregl.Evented["fire"]>[0], object>;
+type BaseEvent = MLEvent & {
+    target: MaplibreglGeocodingControl;
 };
+export declare namespace MaplibreglGeocodingControlEvent {
+    type ReverseToggleEvent = BaseEvent & MaptilerGeocoderEvent.ReverseToggleEvent["detail"];
+    type QueryChangeEvent = BaseEvent & MaptilerGeocoderEvent.QueryChangeEvent["detail"];
+    type QueryClearEvent = BaseEvent;
+    type RequestEvent = BaseEvent & MaptilerGeocoderEvent.RequestEvent["detail"];
+    type ResponseEvent = BaseEvent & MaptilerGeocoderEvent.ResponseEvent["detail"];
+    type SelectEvent = BaseEvent & MaptilerGeocoderEvent.SelectEvent["detail"];
+    type PickEvent = BaseEvent & MaptilerGeocoderEvent.PickEvent["detail"];
+    type FeaturesShowEvent = BaseEvent;
+    type FeaturesHideEvent = BaseEvent;
+    type FeaturesListedEvent = BaseEvent & MaptilerGeocoderEvent.FeaturesListedEvent["detail"];
+    type FeaturesClearEvent = BaseEvent;
+    type FocusInEvent = BaseEvent;
+    type FocusOutEvent = BaseEvent;
+    type MarkerClickEvent = BaseEvent & {
+        feature: Feature;
+        marker: Marker;
+    };
+    type MarkerMouseEnterEvent = BaseEvent & {
+        feature: Feature;
+        marker: Marker;
+    };
+    type MarkerMouseLeaveEvent = BaseEvent & {
+        feature: Feature;
+        marker: Marker;
+    };
+}
+export type ReverseToggleEvent = MaplibreglGeocodingControlEvent.ReverseToggleEvent;
+export type QueryChangeEvent = MaplibreglGeocodingControlEvent.QueryChangeEvent;
+export type QueryClearEvent = MaplibreglGeocodingControlEvent.QueryClearEvent;
+export type RequestEvent = MaplibreglGeocodingControlEvent.RequestEvent;
+export type ResponseEvent = MaplibreglGeocodingControlEvent.ResponseEvent;
+export type SelectEvent = MaplibreglGeocodingControlEvent.SelectEvent;
+export type PickEvent = MaplibreglGeocodingControlEvent.PickEvent;
+export type FeaturesShowEvent = MaplibreglGeocodingControlEvent.FeaturesShowEvent;
+export type FeaturesHideEvent = MaplibreglGeocodingControlEvent.FeaturesHideEvent;
+export type FeaturesListedEvent = MaplibreglGeocodingControlEvent.FeaturesListedEvent;
+export type FeaturesClearEvent = MaplibreglGeocodingControlEvent.FeaturesClearEvent;
+export type FocusInEvent = MaplibreglGeocodingControlEvent.FocusInEvent;
+export type FocusOutEvent = MaplibreglGeocodingControlEvent.FocusOutEvent;
+export type MarkerClickEvent = MaplibreglGeocodingControlEvent.MarkerClickEvent;
+export type MarkerMouseEnterEvent = MaplibreglGeocodingControlEvent.MarkerMouseEnterEvent;
+export type MarkerMouseLeaveEvent = MaplibreglGeocodingControlEvent.MarkerMouseLeaveEvent;
 export type MaplibreglGeocodingControlEventNameMap = {
     reversetoggle: ReverseToggleEvent;
     querychange: QueryChangeEvent;
-    queryclear: never;
+    queryclear: QueryClearEvent;
     request: RequestEvent;
     response: ResponseEvent;
     select: SelectEvent;
     pick: PickEvent;
-    featuresshow: never;
-    featureshide: never;
+    featuresshow: FeaturesShowEvent;
+    featureshide: FeaturesHideEvent;
     featureslisted: FeaturesListedEvent;
-    featuresclear: never;
-    focusin: never;
-    focusout: never;
+    featuresclear: FeaturesClearEvent;
+    focusin: FocusInEvent;
+    focusout: FocusOutEvent;
     markerclick: MarkerClickEvent;
     markermouseenter: MarkerMouseEnterEvent;
     markermouseleave: MarkerMouseLeaveEvent;

package/dist/src/controls/maptilersdk-control.d.ts

@@ -1,7 +1,13 @@
-import { Map as SDKMap } from '@maptiler/sdk';
+import { Map as SDKMap, Subscription } from '@maptiler/sdk';
 import { GeocodingControlBase } from './base-control';
 import { MaplibreglGeocodingControl } from './maplibregl-control';
+import { MaptilerGeocodingControlEventName, MaptilerGeocodingControlEventNameMap } from './maptilersdk-events';
 import { MaptilerGeocodingControlOptions } from './maptilersdk-options';
+type EventHandlingMethod<Return> = <Type extends MaptilerGeocodingControlEventName>(type: Type, listener: (event: MaptilerGeocodingControlEventNameMap[Type]) => void) => Return;
+interface EventOnceHandlingMethod<Return> {
+    <Type extends MaptilerGeocodingControlEventName>(type: Type, listener: (event: MaptilerGeocodingControlEventNameMap[Type]) => void): Return;
+    <Type extends MaptilerGeocodingControlEventName>(type: Type, listener?: undefined): Promise<MaptilerGeocodingControlEventNameMap[Type]>;
+}
 export declare class MaptilerGeocodingControl extends MaplibreglGeocodingControl implements GeocodingControlBase<MaptilerGeocodingControlOptions> {
     #private;
     constructor(options?: MaptilerGeocodingControlOptions);
@@ -11,4 +17,8 @@ export declare class MaptilerGeocodingControl extends MaplibreglGeocodingControl
     onRemove(): void;
     getOptions: () => MaptilerGeocodingControlOptions;
     setOptions(options: MaptilerGeocodingControlOptions): void;
+    on: EventHandlingMethod<Subscription>;
+    off: EventHandlingMethod<this>;
+    once: EventOnceHandlingMethod<this>;
 }
+export {};

package/dist/src/controls/maptilersdk-events.d.ts

@@ -1,2 +1,72 @@
-import { FeaturesListedEvent, MaplibreglGeocodingControlEvent, MaplibreglGeocodingControlEventName, MaplibreglGeocodingControlEventNameMap, MarkerClickEvent, MarkerMouseEnterEvent, MarkerMouseLeaveEvent, PickEvent, QueryChangeEvent, RequestEvent, ResponseEvent, ReverseToggleEvent, SelectEvent } from './maplibregl-events';
-export type { FeaturesListedEvent, MaplibreglGeocodingControlEvent as MaptilerGeocodingControlEvent, MaplibreglGeocodingControlEventName as MaptilerGeocodingControlEventName, MaplibreglGeocodingControlEventNameMap as MaptilerGeocodingControlEventNameMap, MarkerClickEvent, MarkerMouseEnterEvent, MarkerMouseLeaveEvent, PickEvent, QueryChangeEvent, RequestEvent, ResponseEvent, ReverseToggleEvent, SelectEvent, };
+import { Marker, Map as SDKMap } from '@maptiler/sdk';
+import { MaptilerGeocoderEvent } from '../geocoder/geocoder-events';
+import { Feature } from '../types';
+import { MaptilerGeocodingControl } from './maptilersdk-control';
+type SDKEvent = Extract<Parameters<SDKMap["fire"]>[0], object>;
+type BaseEvent = SDKEvent & {
+    target: MaptilerGeocodingControl;
+};
+export declare namespace MaptilerGeocodingControlEvent {
+    type ReverseToggleEvent = BaseEvent & MaptilerGeocoderEvent.ReverseToggleEvent["detail"];
+    type QueryChangeEvent = BaseEvent & MaptilerGeocoderEvent.QueryChangeEvent["detail"];
+    type QueryClearEvent = BaseEvent;
+    type RequestEvent = BaseEvent & MaptilerGeocoderEvent.RequestEvent["detail"];
+    type ResponseEvent = BaseEvent & MaptilerGeocoderEvent.ResponseEvent["detail"];
+    type SelectEvent = BaseEvent & MaptilerGeocoderEvent.SelectEvent["detail"];
+    type PickEvent = BaseEvent & MaptilerGeocoderEvent.PickEvent["detail"];
+    type FeaturesShowEvent = BaseEvent;
+    type FeaturesHideEvent = BaseEvent;
+    type FeaturesListedEvent = BaseEvent & MaptilerGeocoderEvent.FeaturesListedEvent["detail"];
+    type FeaturesClearEvent = BaseEvent;
+    type FocusInEvent = BaseEvent;
+    type FocusOutEvent = BaseEvent;
+    type MarkerClickEvent = BaseEvent & {
+        feature: Feature;
+        marker: Marker;
+    };
+    type MarkerMouseEnterEvent = BaseEvent & {
+        feature: Feature;
+        marker: Marker;
+    };
+    type MarkerMouseLeaveEvent = BaseEvent & {
+        feature: Feature;
+        marker: Marker;
+    };
+}
+export type ReverseToggleEvent = MaptilerGeocodingControlEvent.ReverseToggleEvent;
+export type QueryChangeEvent = MaptilerGeocodingControlEvent.QueryChangeEvent;
+export type QueryClearEvent = MaptilerGeocodingControlEvent.QueryClearEvent;
+export type RequestEvent = MaptilerGeocodingControlEvent.RequestEvent;
+export type ResponseEvent = MaptilerGeocodingControlEvent.ResponseEvent;
+export type SelectEvent = MaptilerGeocodingControlEvent.SelectEvent;
+export type PickEvent = MaptilerGeocodingControlEvent.PickEvent;
+export type FeaturesShowEvent = MaptilerGeocodingControlEvent.FeaturesShowEvent;
+export type FeaturesHideEvent = MaptilerGeocodingControlEvent.FeaturesHideEvent;
+export type FeaturesListedEvent = MaptilerGeocodingControlEvent.FeaturesListedEvent;
+export type FeaturesClearEvent = MaptilerGeocodingControlEvent.FeaturesClearEvent;
+export type FocusInEvent = MaptilerGeocodingControlEvent.FocusInEvent;
+export type FocusOutEvent = MaptilerGeocodingControlEvent.FocusOutEvent;
+export type MarkerClickEvent = MaptilerGeocodingControlEvent.MarkerClickEvent;
+export type MarkerMouseEnterEvent = MaptilerGeocodingControlEvent.MarkerMouseEnterEvent;
+export type MarkerMouseLeaveEvent = MaptilerGeocodingControlEvent.MarkerMouseLeaveEvent;
+export type MaptilerGeocodingControlEventNameMap = {
+    reversetoggle: ReverseToggleEvent;
+    querychange: QueryChangeEvent;
+    queryclear: QueryClearEvent;
+    request: RequestEvent;
+    response: ResponseEvent;
+    select: SelectEvent;
+    pick: PickEvent;
+    featuresshow: FeaturesShowEvent;
+    featureshide: FeaturesHideEvent;
+    featureslisted: FeaturesListedEvent;
+    featuresclear: FeaturesClearEvent;
+    focusin: FocusInEvent;
+    focusout: FocusOutEvent;
+    markerclick: MarkerClickEvent;
+    markermouseenter: MarkerMouseEnterEvent;
+    markermouseleave: MarkerMouseLeaveEvent;
+};
+export type MaptilerGeocodingControlEvent = MaptilerGeocodingControlEventNameMap[keyof MaptilerGeocodingControlEventNameMap];
+export type MaptilerGeocodingControlEventName = keyof MaptilerGeocodingControlEventNameMap;
+export {};

package/dist/src/controls/openlayers-control.d.ts

@@ -3,17 +3,17 @@ import { Types as ObjectEventTypes } from 'ol/ObjectEventType';
 import { EventTypes } from 'ol/Observable';
 import { Control } from 'ol/control';
 import { EventsKey } from 'ol/events';
-import { default as BaseEvent } from 'ol/events/Event';
+import { default as OLEvent } from 'ol/events/Event';
 import { GeocodingControlBase } from './base-control';
 import { OpenLayersGeocodingControlEventName, OpenLayersGeocodingControlEventNameMap } from './openlayers-events';
 import { OpenLayersGeocodingControlOptions } from './openlayers-options';
-type TypedBaseEvent<Type extends OpenLayersGeocodingControlEventName> = BaseEvent & {
+type TypedBaseEvent<Type extends OpenLayersGeocodingControlEventName> = OLEvent & {
     type: Type;
 } & OpenLayersGeocodingControlEventNameMap[Type];
 interface EventHandlingMethod {
-    (type: EventTypes | ObjectEventTypes, listener: (event: BaseEvent) => unknown): EventsKey;
+    (type: EventTypes | ObjectEventTypes, listener: (event: OLEvent) => unknown): EventsKey;
     <Type extends OpenLayersGeocodingControlEventName>(type: Type, listener: (event: TypedBaseEvent<Type>) => unknown): EventsKey;
-    (type: Array<EventTypes | ObjectEventTypes | OpenLayersGeocodingControlEventName>, listener: (event: BaseEvent) => unknown): EventsKey[];
+    (type: Array<EventTypes | ObjectEventTypes | OpenLayersGeocodingControlEventName>, listener: (event: OLEvent) => unknown): EventsKey[];
 }
 export declare class OpenLayersGeocodingControl extends Control implements GeocodingControlBase<OpenLayersGeocodingControlOptions> {
     #private;

package/dist/src/controls/openlayers-events.d.ts

@@ -1,43 +1,73 @@
 import { Feature as OlFeature } from 'ol';
+import { default as OLEvent } from 'ol/events/Event';
 import { Point as OlPoint } from 'ol/geom';
+import { MaptilerGeocoderEvent } from '../geocoder/geocoder-events';
 import { Feature } from '../types';
-import type * as Geocoder from "../geocoder/geocoder-events";
-export type ReverseToggleEvent = Geocoder.ReverseToggleEvent["detail"];
-export type QueryChangeEvent = Geocoder.QueryChangeEvent["detail"];
-export type FeaturesListedEvent = Geocoder.FeaturesListedEvent["detail"];
-export type RequestEvent = Geocoder.RequestEvent["detail"];
-export type ResponseEvent = Geocoder.ResponseEvent["detail"];
-export type SelectEvent = Geocoder.SelectEvent["detail"];
-export type PickEvent = Geocoder.PickEvent["detail"];
-export type MarkerClickEvent = {
-    feature: Feature;
-    marker: OlFeature<OlPoint>;
-};
-export type MarkerMouseEnterEvent = {
-    feature: Feature;
-    marker: OlFeature<OlPoint>;
-};
-export type MarkerMouseLeaveEvent = {
-    feature: Feature;
-    marker: OlFeature<OlPoint>;
+import { OpenLayersGeocodingControl } from './openlayers-control';
+type BaseEvent = OLEvent & {
+    target: OpenLayersGeocodingControl;
 };
+export declare namespace OpenLayersGeocodingControlEvent {
+    type ReverseToggleEvent = BaseEvent & MaptilerGeocoderEvent.ReverseToggleEvent["detail"];
+    type QueryChangeEvent = BaseEvent & MaptilerGeocoderEvent.QueryChangeEvent["detail"];
+    type QueryClearEvent = BaseEvent;
+    type RequestEvent = BaseEvent & MaptilerGeocoderEvent.RequestEvent["detail"];
+    type ResponseEvent = BaseEvent & MaptilerGeocoderEvent.ResponseEvent["detail"];
+    type SelectEvent = BaseEvent & MaptilerGeocoderEvent.SelectEvent["detail"];
+    type PickEvent = BaseEvent & MaptilerGeocoderEvent.PickEvent["detail"];
+    type FeaturesShowEvent = BaseEvent;
+    type FeaturesHideEvent = BaseEvent;
+    type FeaturesListedEvent = BaseEvent & MaptilerGeocoderEvent.FeaturesListedEvent["detail"];
+    type FeaturesClearEvent = BaseEvent;
+    type FocusInEvent = BaseEvent;
+    type FocusOutEvent = BaseEvent;
+    type MarkerClickEvent = BaseEvent & {
+        feature: Feature;
+        marker: OlFeature<OlPoint>;
+    };
+    type MarkerMouseEnterEvent = BaseEvent & {
+        feature: Feature;
+        marker: OlFeature<OlPoint>;
+    };
+    type MarkerMouseLeaveEvent = BaseEvent & {
+        feature: Feature;
+        marker: OlFeature<OlPoint>;
+    };
+}
+export type ReverseToggleEvent = OpenLayersGeocodingControlEvent.ReverseToggleEvent;
+export type QueryChangeEvent = OpenLayersGeocodingControlEvent.QueryChangeEvent;
+export type QueryClearEvent = OpenLayersGeocodingControlEvent.QueryClearEvent;
+export type RequestEvent = OpenLayersGeocodingControlEvent.RequestEvent;
+export type ResponseEvent = OpenLayersGeocodingControlEvent.ResponseEvent;
+export type SelectEvent = OpenLayersGeocodingControlEvent.SelectEvent;
+export type PickEvent = OpenLayersGeocodingControlEvent.PickEvent;
+export type FeaturesShowEvent = OpenLayersGeocodingControlEvent.FeaturesShowEvent;
+export type FeaturesHideEvent = OpenLayersGeocodingControlEvent.FeaturesHideEvent;
+export type FeaturesListedEvent = OpenLayersGeocodingControlEvent.FeaturesListedEvent;
+export type FeaturesClearEvent = OpenLayersGeocodingControlEvent.FeaturesClearEvent;
+export type FocusInEvent = OpenLayersGeocodingControlEvent.FocusInEvent;
+export type FocusOutEvent = OpenLayersGeocodingControlEvent.FocusOutEvent;
+export type MarkerClickEvent = OpenLayersGeocodingControlEvent.MarkerClickEvent;
+export type MarkerMouseEnterEvent = OpenLayersGeocodingControlEvent.MarkerMouseEnterEvent;
+export type MarkerMouseLeaveEvent = OpenLayersGeocodingControlEvent.MarkerMouseLeaveEvent;
 export type OpenLayersGeocodingControlEventNameMap = {
     reversetoggle: ReverseToggleEvent;
     querychange: QueryChangeEvent;
-    queryclear: never;
+    queryclear: QueryClearEvent;
     request: RequestEvent;
     response: ResponseEvent;
     select: SelectEvent;
     pick: PickEvent;
-    featuresshow: never;
-    featureshide: never;
+    featuresshow: FeaturesShowEvent;
+    featureshide: FeaturesHideEvent;
     featureslisted: FeaturesListedEvent;
-    featuresclear: never;
-    focusin: never;
-    focusout: never;
+    featuresclear: FeaturesClearEvent;
+    focusin: FocusInEvent;
+    focusout: FocusOutEvent;
     markerclick: MarkerClickEvent;
     markermouseenter: MarkerMouseEnterEvent;
     markermouseleave: MarkerMouseLeaveEvent;
 };
 export type OpenLayersGeocodingControlEvent = OpenLayersGeocodingControlEventNameMap[keyof OpenLayersGeocodingControlEventNameMap];
 export type OpenLayersGeocodingControlEventName = keyof OpenLayersGeocodingControlEventNameMap;
+export {};

package/dist/src/geocoder/geocoder-events.d.ts

@@ -1,32 +1,45 @@
 import { convert } from 'geo-coordinates-parser';
 import { Feature, FeatureCollection } from '../types';
-export type ReverseToggleEvent = CustomEvent<{
-    reverse: boolean;
-}>;
-export type QueryChangeEvent = CustomEvent<{
-    query: string;
-    reverseCoords: ReturnType<typeof convert> | false;
-}>;
-export type QueryClearEvent = CustomEvent<void>;
-export type RequestEvent = CustomEvent<{
-    urlObj: URL;
-}>;
-export type ResponseEvent = CustomEvent<{
-    url: string;
-    featureCollection: FeatureCollection;
-}>;
-export type SelectEvent = CustomEvent<{
-    feature: Feature | undefined;
-}>;
-export type PickEvent = CustomEvent<{
-    feature: Feature | undefined;
-}>;
-export type FeaturesShowEvent = CustomEvent<void>;
-export type FeaturesHideEvent = CustomEvent<void>;
-export type FeaturesListedEvent = CustomEvent<{
-    features: Feature[] | undefined;
-}>;
-export type FeaturesClearEvent = CustomEvent<void>;
+export declare namespace MaptilerGeocoderEvent {
+    type ReverseToggleEvent = CustomEvent<{
+        reverse: boolean;
+    }>;
+    type QueryChangeEvent = CustomEvent<{
+        query: string;
+        reverseCoords: ReturnType<typeof convert> | false;
+    }>;
+    type QueryClearEvent = CustomEvent<void>;
+    type RequestEvent = CustomEvent<{
+        urlObj: URL;
+    }>;
+    type ResponseEvent = CustomEvent<{
+        url: string;
+        featureCollection: FeatureCollection;
+    }>;
+    type SelectEvent = CustomEvent<{
+        feature: Feature | undefined;
+    }>;
+    type PickEvent = CustomEvent<{
+        feature: Feature | undefined;
+    }>;
+    type FeaturesShowEvent = CustomEvent<void>;
+    type FeaturesHideEvent = CustomEvent<void>;
+    type FeaturesListedEvent = CustomEvent<{
+        features: Feature[] | undefined;
+    }>;
+    type FeaturesClearEvent = CustomEvent<void>;
+}
+export type ReverseToggleEvent = MaptilerGeocoderEvent.ReverseToggleEvent;
+export type QueryChangeEvent = MaptilerGeocoderEvent.QueryChangeEvent;
+export type QueryClearEvent = MaptilerGeocoderEvent.QueryClearEvent;
+export type RequestEvent = MaptilerGeocoderEvent.RequestEvent;
+export type ResponseEvent = MaptilerGeocoderEvent.ResponseEvent;
+export type SelectEvent = MaptilerGeocoderEvent.SelectEvent;
+export type PickEvent = MaptilerGeocoderEvent.PickEvent;
+export type FeaturesShowEvent = MaptilerGeocoderEvent.FeaturesShowEvent;
+export type FeaturesHideEvent = MaptilerGeocoderEvent.FeaturesHideEvent;
+export type FeaturesListedEvent = MaptilerGeocoderEvent.FeaturesListedEvent;
+export type FeaturesClearEvent = MaptilerGeocoderEvent.FeaturesClearEvent;
 export type MaptilerGeocoderEventNameMap = {
     reversetoggle: ReverseToggleEvent;
     querychange: QueryChangeEvent;

package/dist/src/geocoder/geocoder-options.d.ts

@@ -119,9 +119,7 @@ export type MaptilerGeocoderOptions = {
     /**
      * Base URL for POI icons.
      *
-     * Default:
-     * - `"icons/"` for Svelte apps.
-     * - `"https://cdn.maptiler.com/maptiler-geocoding-control/v${version}/icons/"` for others.
+     * Default: `"https://cdn.maptiler.com/maptiler-geocoding-control/v${version}/icons/"`
      */
     iconsBaseUrl?: string;
     /**

package/dist/src/leaflet.public.d.ts

@@ -2,6 +2,6 @@ export * from '.';
 export * from './components/marker';
 export * from './controls/leaflet-control';
 export { LeafletGeocodingControl as GeocodingControl } from './controls/leaflet-control';
-export type * as GeocodingControlEvent from './controls/leaflet-events';
+export type { FeaturesClearEvent, FeaturesHideEvent, FeaturesListedEvent, FeaturesShowEvent, FocusInEvent, FocusOutEvent, LeafletGeocodingControlEvent as GeocodingControlEvent, LeafletGeocodingControlEventName as GeocodingControlEventName, LeafletGeocodingControlEventNameMap as GeocodingControlEventNameMap, LeafletGeocodingControlEvent, LeafletGeocodingControlEventName, LeafletGeocodingControlEventNameMap, MarkerClickEvent, MarkerMouseEnterEvent, MarkerMouseLeaveEvent, PickEvent, QueryChangeEvent, QueryClearEvent, RequestEvent, ResponseEvent, ReverseToggleEvent, SelectEvent, } from './controls/leaflet-events';
 export * from './controls/leaflet-options';
 export type { LeafletGeocodingControlOptions as GeocodingControlOptions } from './controls/leaflet-options';

package/dist/src/maplibregl.d.ts

@@ -2,6 +2,6 @@ export * from '.';
 export * from './components/marker';
 export * from './controls/maplibregl-control';
 export { MaplibreglGeocodingControl as GeocodingControl } from './controls/maplibregl-control';
-export type * as GeocodingControlEvent from './controls/maplibregl-events';
+export type { FeaturesClearEvent, FeaturesHideEvent, FeaturesListedEvent, FeaturesShowEvent, FocusInEvent, FocusOutEvent, MaplibreglGeocodingControlEvent as GeocodingControlEvent, MaplibreglGeocodingControlEventName as GeocodingControlEventName, MaplibreglGeocodingControlEventNameMap as GeocodingControlEventNameMap, MaplibreglGeocodingControlEvent, MaplibreglGeocodingControlEventName, MaplibreglGeocodingControlEventNameMap, MarkerClickEvent, MarkerMouseEnterEvent, MarkerMouseLeaveEvent, PickEvent, QueryChangeEvent, QueryClearEvent, RequestEvent, ResponseEvent, ReverseToggleEvent, SelectEvent, } from './controls/maplibregl-events';
 export * from './controls/maplibregl-options';
 export type { MaplibreglGeocodingControlOptions as GeocodingControlOptions } from './controls/maplibregl-options';

package/dist/src/maptilersdk.d.ts

@@ -2,6 +2,6 @@ export * from '.';
 export * from './components/marker';
 export * from './controls/maptilersdk-control';
 export { MaptilerGeocodingControl as GeocodingControl } from './controls/maptilersdk-control';
-export type * as GeocodingControlEvent from './controls/maptilersdk-events';
+export type { FeaturesClearEvent, FeaturesHideEvent, FeaturesListedEvent, FeaturesShowEvent, FocusInEvent, FocusOutEvent, MaptilerGeocodingControlEvent as GeocodingControlEvent, MaptilerGeocodingControlEventName as GeocodingControlEventName, MaptilerGeocodingControlEventNameMap as GeocodingControlEventNameMap, MaptilerGeocodingControlEvent, MaptilerGeocodingControlEventName, MaptilerGeocodingControlEventNameMap, MarkerClickEvent, MarkerMouseEnterEvent, MarkerMouseLeaveEvent, PickEvent, QueryChangeEvent, QueryClearEvent, RequestEvent, ResponseEvent, ReverseToggleEvent, SelectEvent, } from './controls/maptilersdk-events';
 export * from './controls/maptilersdk-options';
 export type { MaptilerGeocodingControlOptions as GeocodingControlOptions } from './controls/maptilersdk-options';

package/dist/src/openlayers.public.d.ts

@@ -2,6 +2,6 @@ export * from '.';
 export * from './components/marker';
 export * from './controls/openlayers-control';
 export { OpenLayersGeocodingControl as GeocodingControl } from './controls/openlayers-control';
-export type * as GeocodingControlEvent from './controls/openlayers-events';
+export type { FeaturesClearEvent, FeaturesHideEvent, FeaturesListedEvent, FeaturesShowEvent, FocusInEvent, FocusOutEvent, OpenLayersGeocodingControlEvent as GeocodingControlEvent, OpenLayersGeocodingControlEventName as GeocodingControlEventName, OpenLayersGeocodingControlEventNameMap as GeocodingControlEventNameMap, MarkerClickEvent, MarkerMouseEnterEvent, MarkerMouseLeaveEvent, OpenLayersGeocodingControlEvent, OpenLayersGeocodingControlEventName, OpenLayersGeocodingControlEventNameMap, PickEvent, QueryChangeEvent, QueryClearEvent, RequestEvent, ResponseEvent, ReverseToggleEvent, SelectEvent, } from './controls/openlayers-events';
 export * from './controls/openlayers-options';
 export type { OpenLayersGeocodingControlOptions as GeocodingControlOptions } from './controls/openlayers-options';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maptiler/geocoding-control",
-  "version": "3.0.0-rc.4",
+  "version": "3.0.0-rc.5",
   "description": "The Javascript & TypeScript Map Control component for MapTiler Geocoding service. Easy to be integrated into any JavaScript mapping application.",
   "type": "module",
   "author": {