@konce-pt/angular 0.7.0 → 0.7.5

package/types/konce-pt-angular-map.d.ts

@@ -0,0 +1,1585 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, InjectionToken, Provider, WritableSignal } from '@angular/core';
+import { KptI18n, KptOption } from '@konce-pt/angular';
+import { Observable } from 'rxjs';
+import * as _angular_forms_signals from '@angular/forms/signals';
+import { FormValueControl } from '@angular/forms/signals';
+
+/** Punkt geograficzny w stopniach (WGS 84). */
+interface KptLatLng {
+    lat: number;
+    lng: number;
+}
+/** Prostokąt geograficzny. `south < north`; `west`/`east` w stopniach. */
+interface KptMapBounds {
+    south: number;
+    west: number;
+    north: number;
+    east: number;
+}
+/** Punkt w pikselach — kontenera mapy albo świata, zależnie od kontekstu. */
+interface KptMapPoint {
+    x: number;
+    y: number;
+}
+/**
+ * Kolor znacznika: rola z warstwy semantycznej tokenów albo gotowe `var(--kpt-*)`.
+ * Literały (`#c00`, `rgb(...)`) są celowo niedozwolone — kontrakt repo wymaga tokenów.
+ */
+type KptMapColorRole = 'primary' | 'success' | 'warning' | 'danger' | 'info' | 'muted';
+type KptMapColor = KptMapColorRole | `var(--kpt-${string})`;
+/** Kształt znacznika. */
+type KptMapMarkerShape = 'pin' | 'dot' | 'square';
+/** Typ pola w schemie formularza „dodaj lokalizację". */
+type KptMapFieldType = 'text' | 'textarea' | 'number' | 'date' | 'select' | 'multiselect' | 'checkbox' | 'tel' | 'email' | 'url'
+/** Zdjęcie: wybór pliku (wartość jako `data:`) albo wklejony adres. */
+ | 'image'
+/** Tygodniowy rozkład godzin otwarcia; wartość to `KptMapOpeningHours`. */
+ | 'hours';
+/** Opcja listy wyboru w polu `select` / `multiselect`. */
+interface KptMapFieldOption {
+    value: unknown;
+    label: string;
+}
+/** Definicja jednego pola formularza dodawania lokalizacji. */
+interface KptMapFieldDef {
+    /** Klucz w obiekcie wartości formularza. */
+    key: string;
+    type: KptMapFieldType;
+    label: string;
+    required?: boolean;
+    placeholder?: string;
+    /** Tekst pomocniczy pod polem. */
+    hint?: string;
+    /** Wymagane dla `select` i `multiselect`. */
+    options?: KptMapFieldOption[];
+    /** Dolna granica dla `number`; dla `date` data w formacie ISO. */
+    min?: number | string;
+    /** Górna granica dla `number`; dla `date` data w formacie ISO. */
+    max?: number | string;
+    /** Wartość początkowa; bez niej pole startuje puste (`''`, `null`, `[]`, `false`). */
+    initial?: unknown;
+    /**
+     * Część adresu, którą wypełnić z geokodowania wstecznego współrzędnych kliknięcia.
+     * Działa tylko dla pól tekstowych i tylko gdy aplikacja poda port `KPT_MAP_GEOCODER`.
+     * Nigdy nie nadpisuje tego, co użytkownik już wpisał.
+     */
+    autofill?: KptMapAddressPart;
+}
+/** Rozbiór adresu zwracany przez geokoder. Wszystko opcjonalne — źródła bywają dziurawe. */
+interface KptMapAddress {
+    /** Nazwa ulicy bez numeru. */
+    street?: string;
+    houseNumber?: string;
+    /** Ulica z numerem, gotowa do jednego pola „Adres". */
+    address?: string;
+    city?: string;
+    postcode?: string;
+    /** Województwo / region. */
+    state?: string;
+    /** Powiat / hrabstwo. */
+    county?: string;
+    country?: string;
+    /** Kod ISO 3166-1 alpha-2, wielkimi literami. */
+    countryCode?: string;
+    /** Pełny adres jednym ciągiem, tak jak podał go geokoder. */
+    label?: string;
+}
+/** Pole `KptMapAddress`, którym można wypełnić kontrolkę formularza. */
+type KptMapAddressPart = keyof KptMapAddress;
+/**
+ * Podpowiedź z listy wyszukiwarki adresów (geokodowanie wprost: tekst → miejsce).
+ *
+ * Pochodzi z portu `KPT_MAP_GEOCODER`, więc kształt jest wspólny dla dowolnego
+ * dostawcy — Nominatim, instancji własnej i komercyjnej.
+ */
+interface KptMapSuggestion {
+    /** Stabilny w obrębie jednej odpowiedzi — służy za klucz `track` listy podpowiedzi. */
+    id: string;
+    /** Pełna nazwa jednym ciągiem; to widzi użytkownik na liście. */
+    label: string;
+    /**
+     * Współrzędne, **gdy dostawca podaje je już na liście** — tak robi każdy geokoder
+     * pytany wprost (Nominatim, Photon, Google Geocoding API).
+     *
+     * Brak wartości znaczy, że podpowiedź trzeba jeszcze uzupełnić metodą `resolve()`
+     * portu. Tak działa Google Places Autocomplete: zwraca `placeId` i tekst, a `lat`/`lng`
+     * dociąga się osobnym Place Details — jedno wywołanie na *wybór* użytkownika, a nie
+     * na każdy naciśnięty klawisz. Na tym stoi jego rozliczanie sesyjne, więc to nie jest
+     * dziwactwo jednego dostawcy, tylko wzorzec, który port musi umieć wyrazić.
+     */
+    at?: KptLatLng;
+    /**
+     * Zasięg obiektu, gdy dostawca go podaje. Miasto trafia wtedy w kadr w całości,
+     * zamiast dostać punktowy zoom w środek rynku.
+     */
+    bounds?: KptMapBounds;
+    /** Rozbiór adresu, gdy dostawca go podaje — ten sam typ, co przy geokodowaniu wstecznym. */
+    address?: KptMapAddress;
+}
+/**
+ * Wybrane miejsce — podpowiedź z **pewnymi** współrzędnymi.
+ *
+ * To ten typ wychodzi z `selected` pola wyszukiwania i z `searchSelect` mapy: zanim
+ * zdarzenie poleci, brakujące `at` zostaje dociągnięte przez `resolve()`. Aplikacja
+ * nigdy nie musi sprawdzać, czy współrzędne są.
+ */
+interface KptMapSearchResult extends KptMapSuggestion {
+    at: KptLatLng;
+}
+/** Kategoria obiektu — kolor, ikona i schema formularza. */
+interface KptMapCategory {
+    id: string;
+    /** Etykieta w legendzie i domyślnym popupie. */
+    label: string;
+    color: KptMapColor;
+    /** Nazwa ikony z `KptIconRegistry`; bez niej znacznik nie ma glifu. */
+    icon?: string;
+    /** Domyślnie `'pin'`. */
+    shape?: KptMapMarkerShape;
+    /** Schema formularza „dodaj lokalizację" dla tej kategorii. */
+    fields?: KptMapFieldDef[];
+    /** Pokazać w legendzie. Domyślnie `true`. */
+    legend?: boolean;
+}
+/** Pojedyncza lokalizacja na mapie. */
+interface KptMapLocation<T = unknown> {
+    id: string;
+    at: KptLatLng;
+    categoryId: string;
+    /** Tytuł w popupie oraz `aria-label` znacznika — bez niego znacznik jest niedostępny. */
+    title: string;
+    /** Dowolne dane aplikacji; trafiają do szablonu popupu jako `data`. */
+    data?: T;
+}
+/** Grupa lokalizacji zwinięta w jeden znacznik z licznikiem. */
+interface KptMapCluster<T = unknown> {
+    /** Stabilny w obrębie zoomu: `c:{zoom}:{cellX}:{cellY}`. */
+    id: string;
+    /** Środek ciężkości grupy. */
+    at: KptLatLng;
+    count: number;
+    /** Najliczniejsza kategoria w grupie — źródło koloru przy `clusterColorBy: 'dominant'`. */
+    dominantCategoryId: string;
+    items: KptMapLocation<T>[];
+    /** Zasięg grupy — do `fitBounds` po kliknięciu. */
+    bounds: KptMapBounds;
+}
+/** Element wyniku grupowania: albo grupa, albo pojedyncza lokalizacja. */
+type KptMapClusterEntry<T = unknown> = KptMapCluster<T> | KptMapLocation<T>;
+/** Zawęża wynik `clusterLocations` do grupy. */
+declare function isCluster<T>(entry: KptMapClusterEntry<T>): entry is KptMapCluster<T>;
+/** Pozycja użytkownika z geolokalizacji. */
+interface KptMapUserPosition {
+    at: KptLatLng;
+    /** Promień niepewności w metrach (`GeolocationCoordinates.accuracy`). */
+    accuracy: number;
+    /** Znacznik czasu odczytu. */
+    timestamp: number;
+}
+/** Powód niepowodzenia geolokalizacji. */
+type KptMapGeolocationErrorKind = 'denied' | 'unavailable' | 'timeout' | 'unsupported';
+interface KptMapGeolocationError {
+    kind: KptMapGeolocationErrorKind;
+    message: string;
+}
+/** Zdarzenie utworzenia lokalizacji przez formularz. */
+interface KptMapCreateEvent {
+    at: KptLatLng;
+    categoryId: string;
+    /** Wartości pól wg schemy kategorii (albo z własnego szablonu formularza). */
+    value: Record<string, unknown>;
+}
+/** Widok mapy — środek i zoom. */
+interface KptMapView {
+    center: KptLatLng;
+    zoom: number;
+}
+/** Dzień tygodnia wg ISO-8601: 1 = poniedziałek … 7 = niedziela. */
+type KptMapWeekday = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+/**
+ * Przedział otwarcia w dobie, `HH:MM` w czasie lokalnym miejsca.
+ *
+ * `to` mniejsze albo równe `from` znaczy „przez północ" — przedział kończy się
+ * następnego dnia. `24:00` to prawidłowy koniec doby i nie jest przejściem przez północ.
+ */
+interface KptMapHoursRange {
+    from: string;
+    to: string;
+}
+/** Godziny jednego dnia tygodnia. */
+interface KptMapDayHours {
+    day: KptMapWeekday;
+    /** Zamknięte przez całą dobę — `ranges` jest wtedy ignorowane. */
+    closed?: boolean;
+    ranges: KptMapHoursRange[];
+}
+/** Tygodniowy rozkład godzin. Brakujący dzień znaczy „zamknięte". */
+type KptMapOpeningHours = KptMapDayHours[];
+/** Wiersz „ikona + etykieta + wartość" w karcie miejsca. */
+interface KptMapPoiFact {
+    /** Nazwa ikony z `KptIconRegistry`; bez niej wiersz jest bez glifu. */
+    icon?: string;
+    label: string;
+    value: string;
+}
+/**
+ * Dane karty miejsca (`kpt-map-poi-card`). Aplikacja mapuje na to swój
+ * `KptMapLocation.data` — biblioteka nie narzuca kształtu danych domenowych.
+ */
+interface KptMapPoi {
+    title: string;
+    /** Drugi wiersz nagłówka, obok dystansu. */
+    address?: string;
+    /** Adres zdjęcia albo `data:`; karta nie rozróżnia. Puste = zastępnik z ikoną. */
+    photo?: string;
+    photoAlt?: string;
+    hours?: KptMapOpeningHours;
+    phone?: string;
+    email?: string;
+    website?: string;
+    /** Wiersz współrzędnych; bez tego się nie renderuje. */
+    at?: KptLatLng;
+    /** Dodatkowe wiersze informacyjne, bez akcji. */
+    facts?: KptMapPoiFact[];
+}
+
+interface KptClusterOptions {
+    /** Aktualny zoom mapy — decyduje o gęstości siatki. */
+    zoom: number;
+    /** Bok komórki siatki w pikselach ekranu. Domyślnie 60. */
+    gridSize?: number;
+    /** Powyżej tego zoomu grupowanie jest wyłączone. Domyślnie 16. */
+    maxZoom?: number;
+    /** Ile punktów musi trafić do komórki, żeby powstała grupa. Domyślnie 2. */
+    minPoints?: number;
+    /**
+     * Kolejność kategorii — rozstrzyga remis przy wyborze kategorii dominującej.
+     * Bez niej remis rozstrzyga kolejność wystąpienia w danych.
+     */
+    categoryOrder?: readonly string[];
+}
+declare const KPT_CLUSTER_DEFAULTS: {
+    readonly gridSize: 60;
+    readonly maxZoom: 16;
+    readonly minPoints: 2;
+};
+/**
+ * Zwija bliskie sobie lokalizacje w grupy. Zwraca listę mieszaną: grupy i pojedyncze punkty.
+ *
+ * Środek grupy uśredniamy w przestrzeni pikseli, nie w stopniach. Mercator rozciąga
+ * stopnie tym mocniej, im dalej od równika, więc średnia w stopniach wypada obok
+ * wizualnego środka kropek na ekranie — a to jego ma pilnować znacznik grupy.
+ */
+declare function clusterLocations<T>(locations: readonly KptMapLocation<T>[], options: KptClusterOptions): KptMapClusterEntry<T>[];
+/**
+ * Najliczniejsza kategoria w grupie. Remis rozstrzyga `categoryOrder`, a bez niej
+ * kolejność pierwszego wystąpienia — w obu wypadkach wynik jest deterministyczny.
+ */
+declare function dominantCategory<T>(items: readonly KptMapLocation<T>[], categoryOrder?: readonly string[]): string;
+/** Zlicza lokalizacje w rozbiciu na kategorie — licznik obok pozycji legendy. */
+declare function countByCategory<T>(locations: readonly KptMapLocation<T>[]): Record<string, number>;
+/**
+ * Czy grupa da się rozbić przybliżeniem. Punkty o tej samej współrzędnej zostaną razem
+ * na każdym zoomie — wtedy kliknięcie ma otworzyć listę zamiast zoomować w nieskończoność.
+ */
+declare function isSplittable<T>(cluster: KptMapCluster<T>): boolean;
+
+/** Rodzaj silnika — trafia do `data-engine` na hoście, przydatne w testach i stylach. */
+type KptMapEngineKind = 'leaflet' | 'google';
+interface KptMapEngineInit {
+    center: KptLatLng;
+    zoom: number;
+    minZoom?: number;
+    maxZoom?: number;
+    /** Blokada panningu poza prostokąt. */
+    maxBounds?: KptMapBounds | null;
+    /** Szablon URL kafli, np. `https://tile.openstreetmap.org/{z}/{x}/{y}.png`. */
+    tileUrl: string;
+    /** Tekst atrybucji — wymagany licencyjnie przy OSM. */
+    attribution: string;
+    /** Silnik nie rysuje własnych kontrolek zoomu — robi to warstwa Angulara. */
+    interactive?: boolean;
+}
+/** Znacznik gotowy do narysowania — HTML pochodzi z `marker-html.ts`. */
+interface KptMapRenderedMarker {
+    /** Stabilne id: `id` lokalizacji albo `id` grupy. */
+    id: string;
+    at: KptLatLng;
+    html: string;
+    /** Rozmiar ikony w pikselach — silnik potrzebuje go do zakotwiczenia. */
+    size: {
+        width: number;
+        height: number;
+    };
+    /** Punkt zakotwiczenia względem lewego górnego rogu ikony. */
+    anchor: KptMapPoint;
+    /** Kolejność rysowania — grupy nad pojedynczymi punktami. */
+    zIndex?: number;
+}
+interface KptMapPointerEvent {
+    at: KptLatLng;
+    /** Piksele względem kontenera mapy. */
+    point: KptMapPoint;
+    /** Zdarzenie źródłowe, gdy trzeba zatrzymać propagację. */
+    originalEvent?: Event;
+}
+interface KptMapEngineEvents {
+    /** Pan i zoom w toku — używane do przeliczania pozycji popupu. */
+    move: () => void;
+    /** Koniec ruchu — dopiero tu warto emitować `viewChange`. */
+    moveend: () => void;
+    zoomend: () => void;
+    click: (event: KptMapPointerEvent) => void;
+    contextmenu: (event: KptMapPointerEvent) => void;
+    /** Kliknięcie w znacznik; `id` jak w `KptMapRenderedMarker`. */
+    markerclick: (id: string, event: KptMapPointerEvent) => void;
+}
+interface KptMapEngine {
+    readonly kind: KptMapEngineKind;
+    /** Tworzy mapę w kontenerze. Wywoływane po pierwszym renderze, nigdy na SSR. */
+    init(host: HTMLElement, opts: KptMapEngineInit): Promise<void>;
+    destroy(): void;
+    setView(center: KptLatLng, zoom: number, animate?: boolean): void;
+    fitBounds(bounds: KptMapBounds, paddingPx?: number): void;
+    panBy(offset: KptMapPoint): void;
+    getCenter(): KptLatLng;
+    getZoom(): number;
+    getBounds(): KptMapBounds;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    /** Współrzędne → piksele WZGLĘDEM kontenera (pozycjonowanie popupu). */
+    project(at: KptLatLng): KptMapPoint;
+    unproject(point: KptMapPoint): KptLatLng;
+    /** Pełna wymiana zestawu znaczników; diff po `id` robi implementacja. */
+    setMarkers(markers: readonly KptMapRenderedMarker[]): void;
+    /** `null` chowa znacznik użytkownika i krąg dokładności. */
+    setUserPosition(position: KptMapUserPosition | null, html: string): void;
+    setTileSource(tileUrl: string, attribution: string): void;
+    setMaxBounds(bounds: KptMapBounds | null): void;
+    /** Kontener zmienił rozmiar — bez tego Leaflet zostawia szare pola. */
+    invalidateSize(): void;
+    on<K extends keyof KptMapEngineEvents>(event: K, handler: KptMapEngineEvents[K]): void;
+}
+/** Fabryka silnika — to ją dostarcza DI, żeby każda mapa miała własną instancję. */
+type KptMapEngineFactory = () => KptMapEngine;
+/** Domyślne źródło kafli. Do produkcji podstaw własny serwer — patrz llms.txt. */
+declare const KPT_MAP_DEFAULT_TILE_URL = "https://tile.openstreetmap.org/{z}/{x}/{y}.png";
+declare const KPT_MAP_DEFAULT_ATTRIBUTION = "&copy; <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors";
+
+/** Kontekst szablonu popupu — `$implicit` to lokalizacja. */
+interface KptMapPopupContext<T = unknown> {
+    $implicit: KptMapLocation<T>;
+    /** Skrót do `location.data`, żeby nie pisać `loc.data.x` w każdym wierszu. */
+    data: T | undefined;
+    category: KptMapCategory | undefined;
+    /**
+     * Odległość punktu w metrach od `[distanceFrom]`, a bez niego od pozycji użytkownika.
+     * `null`, gdy nie ma punktu odniesienia — geolokalizacja jest wyłączona albo odmówiona.
+     */
+    distance: number | null;
+    close: () => void;
+}
+/**
+ * Szablon popupu szczegółów. Bez atrybutu `category` służy za wariant zapasowy
+ * dla kategorii, które własnego szablonu nie mają.
+ *
+ * Typ `data` domyślnie jest luźny (jak `let-row` w tabeli CDK), bo Angular nie potrafi
+ * przenieść generyka z `kpt-map` na dyrektywę osadzoną w jego treści. Kto chce pełnego
+ * wnioskowania, wiąże `[kptMapPopupTypeFor]` z tą samą tablicą, którą karmi mapę —
+ * wtedy `data` dostaje konkretny typ.
+ *
+ * @example
+ * <ng-template kptMapPopup category="closure" let-loc let-data="data" let-dist="distance">
+ *   <strong>{{ loc.title }}</strong>
+ *   <p>{{ data.address }}</p>
+ * </ng-template>
+ *
+ * @example
+ * // z wnioskowaniem typu
+ * <ng-template kptMapPopup [kptMapPopupTypeFor]="locations()" let-data="data">
+ *   <p>{{ data.address }}</p>
+ * </ng-template>
+ */
+declare class KptMapPopupTemplate<T = any> {
+    /** Kategoria, do której szablon się stosuje; pusta wartość = szablon zapasowy. */
+    readonly category: _angular_core.InputSignal<string>;
+    /**
+     * Nośnik typu — w runtime nieużywany. Jedyne zadanie: pozwolić Angularowi wywnioskować
+     * `T` z tablicy lokalizacji, tak jak `ngFor` wnioskuje typ elementu z bindowanej kolekcji.
+     */
+    readonly typeFor: _angular_core.InputSignal<readonly KptMapLocation<T>[] | undefined>;
+    readonly templateRef: TemplateRef<KptMapPopupContext<T>>;
+    /** Zawęża typ kontekstu w szablonie (`strictTemplates`). */
+    static ngTemplateContextGuard<T>(_dir: KptMapPopupTemplate<T>, _ctx: unknown): _ctx is KptMapPopupContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMapPopupTemplate<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KptMapPopupTemplate<any>, "ng-template[kptMapPopup]", never, { "category": { "alias": "category"; "required": false; "isSignal": true; }; "typeFor": { "alias": "kptMapPopupTypeFor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Kontekst szablonu formularza dodawania lokalizacji. */
+interface KptMapCreateFormContext {
+    $implicit: KptMapCreateFormApi;
+    at: KptLatLng;
+    category: KptMapCategory | undefined;
+}
+interface KptMapCreateFormApi {
+    at: KptLatLng;
+    category: KptMapCategory | undefined;
+    /** Zamyka dialog bez zapisu. */
+    close: () => void;
+    /** Zamyka dialog i emituje `locationCreate` z podanymi wartościami. */
+    submit: (value: Record<string, unknown>) => void;
+}
+/**
+ * Własny formularz „dodaj lokalizację". Jego obecność wyłącza formularz budowany
+ * ze schemy kategorii.
+ *
+ * @example
+ * <ng-template kptMapCreateForm let-api>
+ *   <button (click)="api.submit({ title: 'Nowy punkt' })">Zapisz</button>
+ * </ng-template>
+ */
+declare class KptMapCreateFormTemplate {
+    readonly templateRef: TemplateRef<KptMapCreateFormContext>;
+    static ngTemplateContextGuard(_dir: KptMapCreateFormTemplate, _ctx: unknown): _ctx is KptMapCreateFormContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMapCreateFormTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KptMapCreateFormTemplate, "ng-template[kptMapCreateForm]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Geokodowanie wsteczne: współrzędne → adres. Port, a nie sztywne wywołanie usługi —
+ * biblioteka nie może po cichu odpytywać cudzego serwera, a aplikacje mają własnych dostawców.
+ *
+ * Nie jest rejestrowany domyślnie. Bez niego formularz „dodaj lokalizację" po prostu
+ * nie podpowiada adresu.
+ */
+interface KptMapSearchOptions {
+    /** Język odpowiedzi. Domyślnie to, co ustawi dostawca. */
+    language?: string;
+    signal?: AbortSignal;
+    /** Ile wyników najwyżej. Domyślnie 5 — to lista podpowiedzi, nie wyszukiwarka pełnotekstowa. */
+    limit?: number;
+    /**
+     * Preferuj wyniki z tego prostokąta. **Nie odcina** reszty świata — adres z zagranicy
+     * dalej da się znaleźć, tylko wypada niżej na liście.
+     */
+    viewbox?: KptMapBounds;
+    /** Twarde zawężenie do krajów (ISO 3166-1 alpha-2). Wyniki spoza nich nie wrócą wcale. */
+    countryCodes?: readonly string[];
+}
+interface KptMapGeocoderPort {
+    /** `null` = nie udało się ustalić adresu. Strumień powinien dać jedną wartość i zakończyć się. */
+    reverse(at: KptLatLng, options?: {
+        language?: string;
+        signal?: AbortSignal;
+    }): Observable<KptMapAddress | null>;
+    /**
+     * Geokodowanie wprost: tekst → miejsca. Metoda jest **opcjonalna**, żeby porty napisane
+     * przed jej powstaniem dalej się kompilowały — bez niej `kpt-map` po prostu nie pokazuje
+     * wyszukiwarki. Strumień powinien dać jedną wartość i zakończyć się.
+     *
+     * Zwracać `KptMapSearchResult[]` (ze współrzędnymi) wolno i jest to najprostsza droga —
+     * `KptMapSuggestion` jest tylko szerszy o brak `at`. Jeśli Twój dostawca współrzędnych
+     * na liście nie podaje, **musisz** dopisać `resolve()`.
+     */
+    search?(query: string, options?: KptMapSearchOptions): Observable<readonly KptMapSuggestion[]>;
+    /**
+     * Uzupełnia podpowiedź o współrzędne. Wołane **raz, po wybraniu pozycji z listy** —
+     * nigdy w trakcie pisania.
+     *
+     * Wymagane wyłącznie od dostawców, których `search()` nie zwraca `at` (Google Places:
+     * Autocomplete daje `placeId`, Place Details dokłada `lat`/`lng`). Kto zwraca współrzędne
+     * od razu, tej metody nie potrzebuje — pole wyszukiwania nawet jej nie zawoła.
+     *
+     * `null` = nie udało się ustalić miejsca. Strumień powinien dać jedną wartość i zakończyć się.
+     */
+    resolve?(suggestion: KptMapSuggestion, options?: {
+        language?: string;
+        signal?: AbortSignal;
+    }): Observable<KptMapSearchResult | null>;
+}
+declare const KPT_MAP_GEOCODER: InjectionToken<KptMapGeocoderPort>;
+interface KptNominatimOptions {
+    /**
+     * Adres instancji Nominatim. Domyślnie publiczna instancja OSM — patrz ostrzeżenie
+     * przy `provideKptNominatimGeocoder`.
+     */
+    baseUrl?: string;
+    /** Język odpowiedzi (`Accept-Language`). Domyślnie język przeglądarki. */
+    language?: string;
+    /**
+     * Szczegółowość: 18 to poziom budynku, 16 ulicy, 10 miasta.
+     * Domyślnie 18 — potrzebujemy numeru domu.
+     */
+    zoom?: number;
+    /**
+     * Najmniejszy odstęp między zapytaniami w milisekundach.
+     *
+     * Sekunda nie jest cechą Nominatima, tylko wymogiem regulaminu **publicznej instancji
+     * OSM** — dlatego domyślna zależy od `baseUrl`: bez niego 1000 ms, z własnym adresem 0.
+     * Na swoim serwerze nie ma czego respektować, a przy podpowiadaniu w trakcie pisania
+     * sekundowa zwłoka jest różnicą między „działa" a „zacina się".
+     *
+     * `0` zdejmuje też kolejkowanie — zapytania lecą równolegle. Podstawiając cudzą,
+     * współdzieloną instancję ustaw wartość jawnie.
+     */
+    minIntervalMs?: number;
+}
+/**
+ * Adapter Nominatim (OpenStreetMap). Kolejkuje zapytania z odstępem sekundy, żeby
+ * nie łamać polityki użycia, i przerywa je, gdy subskrybent zniknie.
+ */
+declare class KptNominatimGeocoder implements KptMapGeocoderPort {
+    private readonly options;
+    /** Ogon kolejki — każde kolejne zapytanie czeka na swoją kolej. */
+    private next;
+    /** Kiedy wystrzeliło poprzednie zapytanie. `0` = jeszcze żadne. */
+    private lastAt;
+    /**
+     * Rozstrzygnięty odstęp między zapytaniami. Liczony raz, w konstruktorze: własny
+     * `baseUrl` nie dziedziczy regulaminu publicznej instancji OSM.
+     */
+    private readonly minInterval;
+    constructor(options?: KptNominatimOptions);
+    /**
+     * Rezerwuje miejsce w kolejce: czeka na poprzednie zapytanie, a potem tylko tyle,
+     * ile brakuje do pełnego odstępu od jego wystrzału.
+     *
+     * Odstęp liczony od zegara, a nie stałym `delay()` przed każdym zapytaniem —
+     * inaczej pierwsza podpowiedź po minucie bezczynności też płaciłaby sekundę, a przy
+     * podpowiadaniu w trakcie pisania to jest różnica między „działa" a „zacina się".
+     * Górna granica jednego zapytania na sekundę zostaje nienaruszona.
+     *
+     * Bez odstępu nie ma czego kolejkować: łańcuch obietnic zostaje nietknięty, żeby
+     * podpowiedzi z własnej instancji nie ustawiały się jedna za drugą bez powodu.
+     */
+    private slot;
+    reverse(at: KptLatLng, options?: {
+        language?: string;
+        signal?: AbortSignal;
+    }): Observable<KptMapAddress | null>;
+    /**
+     * Podpowiedzi adresowe. Wchodzi w **tę samą** kolejkę co `reverse()` — polityka Nominatim
+     * liczy jedno zapytanie na sekundę na całego klienta, a nie na metodę.
+     */
+    search(query: string, options?: KptMapSearchOptions): Observable<readonly KptMapSearchResult[]>;
+    private fetchPlaces;
+    private fetchAddress;
+}
+/**
+ * Włącza podpowiadanie adresu z Nominatim (OpenStreetMap) w formularzu „dodaj lokalizację".
+ *
+ * **Polityka użycia.** Publiczna instancja `nominatim.openstreetmap.org` dopuszcza
+ * maksymalnie jedno zapytanie na sekundę, wymaga rozpoznawalnego `Referer`/`User-Agent`
+ * i zabrania masowego odpytywania; ruch może zostać zablokowany bez uprzedzenia,
+ * w szczególności komercyjny. Adapter sam trzyma odstęp sekundy, ale do produkcji
+ * podstaw własną instancję (`baseUrl`) albo komercyjnego dostawcę przez własny
+ * `KPT_MAP_GEOCODER`.
+ *
+ * Podanie `baseUrl` **zdejmuje sekundowy odstęp** (`minIntervalMs` domyślnie 0) — regulamin
+ * publicznej instancji nie obowiązuje na Twoim serwerze. Cudzą, współdzieloną instancję
+ * podstawiaj z jawnym `minIntervalMs`.
+ *
+ * @example
+ * providers: [provideKptLeafletMap(), provideKptNominatimGeocoder({ language: 'pl' })]
+ *
+ * @example
+ * // Własna instancja: bez odstępu, podpowiedzi lecą od razu.
+ * provideKptNominatimGeocoder({ baseUrl: 'https://geo.firma.local', language: 'pl' })
+ */
+declare function provideKptNominatimGeocoder(options?: KptNominatimOptions): Provider;
+interface KptMapGeocoderStubOptions {
+    /**
+     * Udawaj dostawcę, który nie podaje współrzędnych na liście (Google Places Autocomplete):
+     * `search()` oddaje podpowiedzi bez `at`, a dopiero `resolve()` je dokłada.
+     *
+     * Bez tego ścieżki leniwej nie da się pokazać ani przejechać bez prawdziwego klucza API.
+     */
+    deferCoordinates?: boolean;
+}
+/**
+ * Stały adres i stała lista podpowiedzi — Storybook i testy, bez ruchu sieciowego.
+ *
+ * Podpowiedzi filtruje po `label` bez znaków diakrytycznych, żeby „warszawa" trafiało
+ * w „Warszawa". Prawdziwy geokoder dopasowuje po swojemu — atrapa tylko udaje, że umie.
+ */
+declare class KptMapGeocoderStub implements KptMapGeocoderPort {
+    private readonly address;
+    private readonly results;
+    private readonly options;
+    constructor(address: KptMapAddress | null, results?: readonly KptMapSearchResult[], options?: KptMapGeocoderStubOptions);
+    reverse(): Observable<KptMapAddress | null>;
+    search(query: string, options?: KptMapSearchOptions): Observable<readonly KptMapSuggestion[]>;
+    resolve(suggestion: KptMapSuggestion): Observable<KptMapSearchResult | null>;
+}
+declare function provideKptMapGeocoderStub(address: KptMapAddress | null, results?: readonly KptMapSearchResult[], options?: KptMapGeocoderStubOptions): Provider;
+
+interface PopupState<T> {
+    location: KptMapLocation<T>;
+    /** Grupa, z której popup został otwarty — lista nierozdzielalnych punktów. */
+    group: KptMapCluster<T> | null;
+}
+/**
+ * Mapa z konfigurowalnymi znacznikami: kategorie z kolorem i ikoną, grupowanie z licznikiem,
+ * popup szczegółów o szablonie zależnym od kategorii, legenda i dodawanie lokalizacji
+ * prawym przyciskiem myszy.
+ *
+ * Silnik (domyślnie Leaflet + OpenStreetMap) dostarcza `provideKptLeafletMap()`. Wymaga
+ * zainstalowanej paczki `leaflet` (zależność opcjonalna) i dołączonego `leaflet/dist/leaflet.css`.
+ *
+ * @example
+ * <kpt-map [locations]="locations()" [categories]="categories" allowCreate showUserLocation>
+ *   <ng-template kptMapPopup category="closure" let-loc let-data="data">
+ *     <strong>{{ loc.title }}</strong>
+ *     <p>{{ data.address }}</p>
+ *   </ng-template>
+ * </kpt-map>
+ */
+declare class KptMap<T = unknown> {
+    readonly locations: _angular_core.InputSignal<readonly KptMapLocation<T>[]>;
+    readonly categories: _angular_core.InputSignal<readonly KptMapCategory[]>;
+    /** Kod kraju z presetów (`PL`, `DE`, `EU`…). Nieznany kod cofa się do Polski. */
+    readonly country: _angular_core.InputSignal<string>;
+    /** Jawny widok startowy; nadpisuje `country`. */
+    readonly view: _angular_core.InputSignal<KptMapView | null>;
+    /** Blokuje przesuwanie poza zasięg kraju (albo `bounds`, gdy podane). */
+    readonly restrictToCountry: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Jawny zasięg startowy; nadpisuje `country` i `view`. */
+    readonly bounds: _angular_core.InputSignal<KptMapBounds | null>;
+    readonly cluster: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly clusterOptions: _angular_core.InputSignal<Partial<Omit<KptClusterOptions, "zoom">>>;
+    /** `dominant` barwi grupę kolorem najliczniejszej kategorii. */
+    readonly clusterColorBy: _angular_core.InputSignal<"dominant" | "none">;
+    /** Renderuje legendę pod mapą. Wyłącz, jeśli chcesz ją umieścić gdzie indziej. */
+    readonly legend: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Identyfikatory ukrytych kategorii (dwukierunkowe) — legenda je przełącza. */
+    readonly hiddenCategories: _angular_core.ModelSignal<string[]>;
+    /** Pokazuje liczniki przy pozycjach legendy. */
+    readonly legendCounts: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showUserLocation: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Przy każdej nowej pozycji centruje mapę na użytkowniku. */
+    readonly followUser: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Włącza menu „Dodaj lokalizację" pod prawym przyciskiem myszy. */
+    readonly allowCreate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Pokazuje wyszukiwarkę adresów w rogu mapy. Wymaga portu `KPT_MAP_GEOCODER`
+     * **z metodą `search()`** — bez niego pole się nie renderuje, bo biblioteka nie
+     * odpytuje cudzego serwera bez zgody aplikacji.
+     */
+    readonly search: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Podpowiedź w pustym polu wyszukiwania. Pusta oddaje głos słownikowi. */
+    readonly searchPlaceholder: _angular_core.InputSignal<string>;
+    /** Strojenie wyszukiwarki. Domyślnie `3 / 300 ms / 5`. */
+    readonly searchOptions: _angular_core.InputSignal<{
+        minLength?: number;
+        debounce?: number;
+        limit?: number;
+        /** Twarde zawężenie do krajów (ISO 3166-1 alpha-2); nadpisuje regułę `restrictToCountry`. */
+        countryCodes?: readonly string[];
+    }>;
+    /**
+     * Zoom, na jaki mapa wchodzi po wybraniu wyniku bez własnego zasięgu (pojedynczy adres).
+     * Wynik z zasięgiem — miasto, region — dostaje `fitBounds` zamiast tego.
+     */
+    readonly searchZoom: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Zostawia tymczasową pinezkę w znalezionym punkcie. */
+    readonly searchMarker: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Wygląd popupu. `plain` to wąska ramka na treść tekstową (domyślna),
+     * `card` oddaje całą szerokość i wysokość karcie miejsca: bez paddingu,
+     * bez wbudowanego krzyżyka, z przewijaniem, gdy treść nie mieści się w mapie.
+     */
+    readonly popupLayout: _angular_core.InputSignal<"plain" | "card">;
+    /**
+     * Punkt odniesienia dystansu podawanego szablonowi popupu jako `distance`.
+     * `null` znaczy „pozycja użytkownika z `KPT_MAP_GEOLOCATION`", więc domyślnie
+     * jest to odległość od miejsca, w którym stoi patrzący. Aplikacja może podstawić
+     * inny punkt — wyszukany adres, siedzibę firmy, stałą pozycję w demie.
+     */
+    readonly distanceFrom: _angular_core.InputSignal<KptLatLng | null>;
+    readonly height: _angular_core.InputSignal<string>;
+    /** Bez znaczenia dla silnika Google — kafle i atrybucję dostarcza tam Google. */
+    readonly tileUrl: _angular_core.InputSignal<string | null>;
+    readonly attribution: _angular_core.InputSignal<string | null>;
+    /**
+     * Silnik **tej** mapy. Podany wygrywa nad `KPT_MAP_ENGINE` z DI, więc dwie mapy o różnych
+     * silnikach mieszczą się na jednej stronie bez komponentów-opakowań. Bez niego wszystko
+     * działa jak dotąd — silnik przychodzi z DI.
+     *
+     * Fabryka, a nie gotowa instancja: każda mapa potrzebuje własnego obiektu. Czytany raz,
+     * przy inicjalizacji — podmiana po starcie nie przeładowuje mapy.
+     *
+     * @example
+     * readonly google: KptMapEngineFactory = () => createGoogleEngine({ apiKey, mapId });
+     */
+    readonly engine: _angular_core.InputSignal<KptMapEngineFactory | null>;
+    /**
+     * Geokoder **tej** mapy. Podany wygrywa nad `KPT_MAP_GEOCODER` z DI — tak samo jak
+     * `[engine]` nad `KPT_MAP_ENGINE` i z tego samego powodu: Service Specific Terms wiążą
+     * geokoder Google z **mapą** Google, a nie z aplikacją. Na stronie z dwoma silnikami
+     * globalny provider nie umiałby tej reguły dotrzymać; wejście umie.
+     *
+     * Trafia i do wyszukiwarki, i do formularza „dodaj lokalizację" — jeden port na oba kierunki.
+     *
+     * @example
+     * <kpt-map [engine]="google" [geocoder]="googleGeocoder" … />
+     */
+    readonly geocoder: _angular_core.InputSignal<KptMapGeocoderPort | null>;
+    readonly locationClick: _angular_core.OutputEmitterRef<KptMapLocation<T>>;
+    readonly clusterClick: _angular_core.OutputEmitterRef<KptMapCluster<T>>;
+    readonly locationCreate: _angular_core.OutputEmitterRef<KptMapCreateEvent>;
+    /** Wybrano podpowiedź wyszukiwarki. Mapa sama przenosi na nią widok. */
+    readonly searchSelect: _angular_core.OutputEmitterRef<KptMapSearchResult>;
+    readonly viewChange: _angular_core.OutputEmitterRef<{
+        center: KptLatLng;
+        zoom: number;
+        bounds: KptMapBounds;
+    }>;
+    readonly userPositionChange: _angular_core.OutputEmitterRef<KptMapUserPosition | null>;
+    readonly userLocationError: _angular_core.OutputEmitterRef<KptMapGeolocationError>;
+    protected readonly i18n: KptI18n;
+    private readonly icons;
+    /** Opcjonalny, bo silnik może przyjść wejściem `[engine]` zamiast z DI. */
+    private readonly engineFactory;
+    private readonly geolocation;
+    /** Opcjonalny — wejście `[geocoder]` i tak ma nad nim pierwszeństwo. */
+    private readonly injectedGeocoder;
+    private readonly destroyRef;
+    private readonly injector;
+    /** Rozstrzygnięty port geokodera: wejście przed DI. Szablon podaje go dzieciom. */
+    protected readonly activeGeocoder: _angular_core.Signal<KptMapGeocoderPort | null>;
+    private readonly canvas;
+    private readonly popupEl;
+    private readonly popupTemplates;
+    protected readonly createFormTemplate: _angular_core.Signal<KptMapCreateFormTemplate | undefined>;
+    private mapEngine;
+    protected readonly engineKind: _angular_core.WritableSignal<string | null>;
+    protected readonly ready: _angular_core.WritableSignal<boolean>;
+    /** Zoom trzymamy w sygnale, bo od niego zależy wynik grupowania. */
+    private readonly zoom;
+    /** Rośnie przy każdym ruchu mapy — wymusza przeliczenie pozycji popupu. */
+    private readonly viewportTick;
+    protected readonly popup: _angular_core.WritableSignal<PopupState<T> | null>;
+    protected readonly contextTarget: _angular_core.WritableSignal<{
+        at: KptLatLng;
+        point: KptMapPoint;
+    } | null>;
+    protected readonly createFor: _angular_core.WritableSignal<{
+        at: KptLatLng;
+        category: KptMapCategory;
+    } | null>;
+    protected readonly createOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly userPosition: _angular_core.WritableSignal<KptMapUserPosition | null>;
+    /** Ostatni wybrany wynik wyszukiwania — źródło tymczasowej pinezki. */
+    protected readonly searchPin: _angular_core.WritableSignal<KptMapSearchResult | null>;
+    protected readonly locationBlocked: _angular_core.WritableSignal<boolean>;
+    private readonly categoryById;
+    /** Lokalizacje po odfiltrowaniu kategorii ukrytych w legendzie. */
+    private readonly visibleLocations;
+    protected readonly counts: _angular_core.Signal<Record<string, number> | null>;
+    /** Wynik grupowania dla aktualnego zoomu — grupy i punkty pojedyncze. */
+    private readonly entries;
+    /** Znaczniki gotowe dla silnika. HTML powstaje w rdzeniu, poza Angularem. */
+    private readonly markers;
+    /** Szablon popupu dla kategorii; bez dopasowania — szablon zapasowy (bez `category`). */
+    private readonly popupTemplateFor;
+    protected readonly popupTemplate: _angular_core.Signal<KptMapPopupTemplate<T> | null>;
+    protected readonly popupCategory: _angular_core.Signal<KptMapCategory | undefined>;
+    /**
+     * Odległość otwartego punktu od `distanceFrom` (albo od użytkownika) w metrach.
+     * `null`, gdy nie ma od czego liczyć — szablon chowa wtedy wiersz dystansu,
+     * zamiast pokazywać zero.
+     */
+    protected readonly popupDistance: _angular_core.Signal<number | null>;
+    /**
+     * Pozycja popupu w pikselach kontenera. Zależy od `viewportTick`, więc przelicza się
+     * przy każdym ruchu mapy — jeden sygnał zamiast nasłuchu w szablonie.
+     */
+    protected readonly popupPosition: _angular_core.Signal<KptMapPoint | null>;
+    protected readonly contextPosition: _angular_core.Signal<KptMapPoint | null>;
+    /** Kategorie oferowane w menu „dodaj" — ukryte w legendzie odpadają. */
+    protected readonly creatableCategories: _angular_core.Signal<KptMapCategory[]>;
+    /** Czy jest czym szukać — port bez `search()` nie zasługuje na pole, które nic nie robi. */
+    protected readonly searchEnabled: _angular_core.Signal<boolean>;
+    /**
+     * Prostokąt preferowanych wyników. Bierzemy zasięg jawny, a bez niego preset kraju —
+     * „Kwiatowa" ma trafiać w tę pod nosem, nie w tę z drugiego końca świata. To sam bias:
+     * adresu z zagranicy dalej da się poszukać.
+     */
+    protected readonly searchViewbox: _angular_core.Signal<KptMapBounds>;
+    /**
+     * Twarde zawężenie do krajów. Jawne `searchOptions.countryCodes` wygrywa; bez niego
+     * odcinamy zagranicę dopiero przy `restrictToCountry`, bo tam mapa i tak nie pozwoli
+     * przesunąć widoku poza kraj — znaleziony adres byłby nie do pokazania.
+     */
+    protected readonly searchCountryCodes: _angular_core.Signal<readonly string[] | null>;
+    protected readonly createFormApi: _angular_core.Signal<KptMapCreateFormApi | null>;
+    constructor();
+    private restrictBounds;
+    private initEngine;
+    /** Bez tego Leaflet zostawia szare pola po każdej zmianie układu strony. */
+    private observeResize;
+    private watchGeolocation;
+    private emitViewChange;
+    private onMarkerClick;
+    private onContextMenu;
+    protected dismissOverlays(): void;
+    /** Kliknięcie w mapę zamyka nakładki i zdejmuje pinezkę wyniku wyszukiwania. */
+    protected onMapClick(): void;
+    protected clearSearchPin(): void;
+    protected closePopup(): void;
+    /** Zapas na strzałkę i cień popupu przy sprawdzaniu, czy mieści się w kontenerze. */
+    private static readonly POPUP_MARGIN;
+    /**
+     * Przesuwa mapę tak, żeby świeżo otwarty popup zmieścił się w kontenerze.
+     *
+     * Wymiarów popupu nie znamy przed renderem, więc mierzymy go po dograniu ramki.
+     * Bez tego znacznik przy górnej krawędzi otwiera popup poza widokiem.
+     */
+    private autoPanToPopup;
+    /** Gotowa referencja dla kontekstu szablonu — szablon nie ma jak zrobić `bind`. */
+    protected readonly closePopupFn: () => void;
+    /** Pozycja z grupy nierozdzielalnej — przełącza popup bez ruszania mapy. */
+    protected selectFromGroup(location: KptMapLocation<T>): void;
+    protected startCreate(category: KptMapCategory): void;
+    protected closeCreate(): void;
+    protected emitCreate(value: Record<string, unknown>): void;
+    /**
+     * Przenosi widok na wybrany wynik. Zasięg (miasto, region) wpasowujemy w kadr,
+     * a pojedynczy punkt dostaje `[searchZoom]` — inaczej każdy adres lądowałby
+     * w innym przybliżeniu, zależnym od tego, jak dostawca obrysował budynek.
+     */
+    protected onSearchSelect(result: KptMapSearchResult): void;
+    protected zoomBy(delta: number): void;
+    protected centreOnUser(): void;
+    /** Wraca do widoku startowego — po zabłądzeniu na drugim końcu świata. */
+    protected resetView(): void;
+    /** Zasięg wszystkich widocznych lokalizacji — `null`, gdy nie ma żadnej. */
+    protected readonly dataBounds: _angular_core.Signal<KptMapBounds | null>;
+    protected fitToData(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMap<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptMap<any>, "kpt-map", never, { "locations": { "alias": "locations"; "required": true; "isSignal": true; }; "categories": { "alias": "categories"; "required": true; "isSignal": true; }; "country": { "alias": "country"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "restrictToCountry": { "alias": "restrictToCountry"; "required": false; "isSignal": true; }; "bounds": { "alias": "bounds"; "required": false; "isSignal": true; }; "cluster": { "alias": "cluster"; "required": false; "isSignal": true; }; "clusterOptions": { "alias": "clusterOptions"; "required": false; "isSignal": true; }; "clusterColorBy": { "alias": "clusterColorBy"; "required": false; "isSignal": true; }; "legend": { "alias": "legend"; "required": false; "isSignal": true; }; "hiddenCategories": { "alias": "hiddenCategories"; "required": false; "isSignal": true; }; "legendCounts": { "alias": "legendCounts"; "required": false; "isSignal": true; }; "showUserLocation": { "alias": "showUserLocation"; "required": false; "isSignal": true; }; "followUser": { "alias": "followUser"; "required": false; "isSignal": true; }; "allowCreate": { "alias": "allowCreate"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "searchOptions": { "alias": "searchOptions"; "required": false; "isSignal": true; }; "searchZoom": { "alias": "searchZoom"; "required": false; "isSignal": true; }; "searchMarker": { "alias": "searchMarker"; "required": false; "isSignal": true; }; "popupLayout": { "alias": "popupLayout"; "required": false; "isSignal": true; }; "distanceFrom": { "alias": "distanceFrom"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "tileUrl": { "alias": "tileUrl"; "required": false; "isSignal": true; }; "attribution": { "alias": "attribution"; "required": false; "isSignal": true; }; "engine": { "alias": "engine"; "required": false; "isSignal": true; }; "geocoder": { "alias": "geocoder"; "required": false; "isSignal": true; }; }, { "hiddenCategories": "hiddenCategoriesChange"; "locationClick": "locationClick"; "clusterClick": "clusterClick"; "locationCreate": "locationCreate"; "searchSelect": "searchSelect"; "viewChange": "viewChange"; "userPositionChange": "userPositionChange"; "userLocationError": "userLocationError"; }, ["popupTemplates", "createFormTemplate"], never, true, never>;
+}
+
+interface LegendEntry {
+    category: KptMapCategory;
+    colorVar: string;
+    /** Kolor glifu na tle `colorVar`. Zaszyta biel gubi się na jasnych rolach (`muted`). */
+    contrastVar: string;
+    hidden: boolean;
+    count: number | null;
+}
+/**
+ * Legenda mapy — lista kategorii ze znacznikiem koloru i ikoną. Pozycje są przyciskami:
+ * kliknięcie chowa i pokazuje kategorię (`hidden` dwukierunkowe).
+ *
+ * `kpt-map` renderuje ją sam pod mapą przy `[legend]="true"`; kto chce ją gdzie indziej,
+ * wyłącza tamto i wstawia ten komponent ręcznie.
+ *
+ * @example
+ * <kpt-map-legend [categories]="categories" [(hidden)]="hiddenCategories" [counts]="counts" />
+ */
+declare class KptMapLegend {
+    readonly categories: _angular_core.InputSignal<readonly KptMapCategory[]>;
+    /** Identyfikatory ukrytych kategorii (dwukierunkowe). */
+    readonly hidden: _angular_core.ModelSignal<string[]>;
+    /** Opcjonalne liczniki `{ categoryId: liczba }` — pokazywane przy etykiecie. */
+    readonly counts: _angular_core.InputSignal<Record<string, number> | null>;
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /** Wyłącza chowanie kategorii — legenda staje się czysto informacyjna. */
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    protected readonly i18n: KptI18n;
+    protected readonly entries: _angular_core.Signal<LegendEntry[]>;
+    protected toggle(entry: LegendEntry): void;
+    protected label(entry: LegendEntry): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMapLegend, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptMapLegend, "kpt-map-legend", never, { "categories": { "alias": "categories"; "required": true; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "counts": { "alias": "counts"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; }, { "hidden": "hiddenChange"; }, never, never, true, never>;
+}
+
+/**
+ * Wyszukiwarka adresów: pole z podpowiedziami z geokodera. Wynik wyboru leci w `selected`,
+ * a co z nim zrobić — decyduje rodzic (`kpt-map` przenosi na niego widok).
+ *
+ * Wymaga portu `KPT_MAP_GEOCODER` **z metodą `search()`** — biblioteka nie odpytuje cudzego
+ * serwera bez zgody aplikacji. Bez portu pole renderuje się wyłączone, zamiast udawać, że
+ * coś znajdzie; `kpt-map` idzie dalej i w ogóle go wtedy nie pokazuje.
+ *
+ * Świadomie **nie** stoi na `kpt-autocomplete`: tamten filtruje opcje po stronie klienta
+ * (wyniki geokodera, tolerancyjne na literówki, wypadałyby z listy), jego wartością jest
+ * sam `string` (nie ma czym przewieźć współrzędnych) i wymaga CDK Overlay, którego mapa
+ * poza tym nie potrzebuje.
+ *
+ * @example
+ * <kpt-map-search [viewbox]="bounds" (selected)="goTo($event)" />
+ */
+declare class KptMapSearch {
+    /** Podpowiedź w pustym polu. Pusta oddaje głos słownikowi `map.search.placeholder`. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Od ilu znaków pytać geokoder. Krótsze frazy zwracają pół świata. */
+    readonly minLength: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Ile milisekund ciszy przed zapytaniem. */
+    readonly debounce: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Ile podpowiedzi najwyżej. */
+    readonly limit: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Zawężenie twarde do krajów (ISO 3166-1 alpha-2) — wyniki spoza nich nie wrócą. */
+    readonly countryCodes: _angular_core.InputSignal<readonly string[] | null>;
+    /** Preferowany prostokąt wyników. Nie odcina reszty świata, tylko przesuwa ją niżej. */
+    readonly viewbox: _angular_core.InputSignal<KptMapBounds | null>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Geokoder tego pola. Podany wygrywa nad `KPT_MAP_GEOCODER` z DI — `kpt-map` podaje tędy
+     * port swojej mapy, bo geokoder jest per mapa, a nie per aplikacja. Bez niego wszystko
+     * działa jak dotąd: port przychodzi z DI.
+     */
+    readonly geocoder: _angular_core.InputSignal<KptMapGeocoderPort | null>;
+    /**
+     * Wybrano miejsce. **Zawsze ze współrzędnymi**: podpowiedź, której dostawca ich nie podał,
+     * pole najpierw uzupełnia przez `resolve()` portu, a dopiero potem emituje.
+     */
+    readonly selected: _angular_core.OutputEmitterRef<KptMapSearchResult>;
+    /** Pole wyczyszczone — rodzic sprząta po sobie (np. chowa tymczasową pinezkę). */
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    protected readonly i18n: KptI18n;
+    private readonly injectedGeocoder;
+    /** Rozstrzygnięty port: wejście przed DI. Czytany reaktywnie, bo mapa może go podmienić. */
+    private readonly port;
+    protected readonly uid: string;
+    /** Tekst widoczny w polu. Wybór podpowiedzi wpisuje tu jej etykietę. */
+    protected readonly query: _angular_core.WritableSignal<string>;
+    /**
+     * Fraza do odpytania geokodera. Osobna od `query`, bo wybór podpowiedzi zmienia treść
+     * pola — a to nie może wywołać kolejnego zapytania o coś, co już znaleźliśmy.
+     */
+    private readonly term;
+    protected readonly results: _angular_core.WritableSignal<readonly KptMapSuggestion[]>;
+    protected readonly loading: _angular_core.WritableSignal<boolean>;
+    /**
+     * Trwa dociąganie współrzędnych wybranej podpowiedzi (`resolve()` portu). Osobne od
+     * `loading`, bo to inny moment: tam czekamy na listę, tu na jedno konkretne miejsce.
+     */
+    protected readonly resolving: _angular_core.WritableSignal<boolean>;
+    /** Subskrypcja `resolve()` w locie — kolejny wybór i czyszczenie pola ją przerywają. */
+    private pending;
+    /** Czy jakieś zapytanie już wróciło — bez tego „brak wyników" mignąłby przed pierwszym. */
+    protected readonly searched: _angular_core.WritableSignal<boolean>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    /** Fraza za krótka, ale niepusta — zamiast ciszy pokazujemy, ile znaków brakuje. */
+    protected readonly tooShort: _angular_core.Signal<boolean>;
+    protected readonly hasPanel: _angular_core.Signal<boolean>;
+    /** Cokolwiek leci do geokodera — lista albo pojedyncze miejsce. Jeden stan dla szablonu. */
+    protected readonly busy: _angular_core.Signal<boolean>;
+    protected readonly canSearch: _angular_core.Signal<boolean>;
+    /** Nie udało się ustalić miejsca wybranej podpowiedzi — komunikat zamiast cichej ciszy. */
+    private readonly unresolved;
+    /** Komunikat dla `aria-live` — czytnik dostaje stan, którego wzrokowo nie da się przegapić. */
+    protected readonly status: _angular_core.Signal<string>;
+    protected readonly placeholderText: _angular_core.Signal<string>;
+    constructor();
+    /**
+     * Odpytuje geokoder po odczekaniu `debounce` od ostatniego znaku.
+     *
+     * Debounce stoi na `setTimeout`, a nie na operatorach rxjs: porty tego pakietu używają
+     * wyłącznie `Observable`/`of`, a rxjs nie jest zadeklarowany jako `peerDependency`
+     * biblioteki (wchodzi tranzytywnie przez `@angular/core`). `onCleanup` kasuje zarówno
+     * niewystrzelony timer, jak i zapytanie w locie — adapter Nominatim przerywa wtedy
+     * `fetch` własnym `AbortController`.
+     */
+    private watchTerm;
+    private applyResults;
+    protected optionId(index: number): string;
+    protected onInput(event: Event): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    /**
+     * Wybór podpowiedzi. Dostawca, który podał współrzędne na liście, emituje natychmiast —
+     * dla Nominatima i każdego geokodera pytanego wprost nic się nie zmienia.
+     *
+     * Podpowiedź bez `at` (Google Places Autocomplete) trzeba najpierw uzupełnić: jedno
+     * wywołanie `resolve()` na *wybór*, nigdy w trakcie pisania. Panel zostaje otwarty
+     * z komunikatem „Szukam…", żeby czekanie nie wyglądało na zawieszenie pola.
+     */
+    protected pick(suggestion: KptMapSuggestion): void;
+    private applyResolved;
+    protected clear(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMapSearch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptMapSearch, "kpt-map-search", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "debounce": { "alias": "debounce"; "required": false; "isSignal": true; }; "limit": { "alias": "limit"; "required": false; "isSignal": true; }; "countryCodes": { "alias": "countryCodes"; "required": false; "isSignal": true; }; "viewbox": { "alias": "viewbox"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "geocoder": { "alias": "geocoder"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "cleared": "cleared"; }, never, never, true, never>;
+}
+
+/**
+ * Treść dialogu „dodaj lokalizację" budowana ze schemy kategorii (`category.fields`).
+ *
+ * Przy dynamicznej schemie typowanie pól znika — model to `Record<string, unknown>`,
+ * a ścieżki walidatorów trzeba rzutować. Reszta kontraktu Signal Forms zostaje bez zmian:
+ * walidatory deklarujemy raz, a bramka „nie strasz czerwienią" siedzi w prezentacji.
+ */
+declare class KptMapCreateDialog {
+    readonly category: _angular_core.InputSignal<KptMapCategory>;
+    readonly at: _angular_core.InputSignal<KptLatLng>;
+    /**
+     * Geokoder tego formularza. Podany wygrywa nad `KPT_MAP_GEOCODER` z DI — `kpt-map` podaje
+     * tędy port swojej mapy, bo geokoder jest per mapa, a nie per aplikacja.
+     */
+    readonly geocoder: _angular_core.InputSignal<KptMapGeocoderPort | null>;
+    readonly save: _angular_core.OutputEmitterRef<Record<string, unknown>>;
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    protected readonly i18n: KptI18n;
+    private readonly injector;
+    /** Opcjonalny — wejście `[geocoder]` i tak ma nad nim pierwszeństwo. */
+    private readonly injectedGeocoder;
+    /** Rozstrzygnięty port: wejście przed DI. Bez obu formularz po prostu nie podpowiada adresu. */
+    private readonly port;
+    /** Trwa zapytanie do geokodera — szablon pokazuje wtedy notkę zamiast ciszy. */
+    protected readonly geocoding: WritableSignal<boolean>;
+    /** Ostatnio ustalony adres; `label` bywa czytelniejszy niż suma pól. */
+    protected readonly address: WritableSignal<KptMapAddress | null>;
+    protected readonly fields: _angular_core.Signal<readonly KptMapFieldDef[]>;
+    /** Czy kategoria ma pola do podpowiedzenia i jest czym je podpowiedzieć. */
+    protected readonly hasAutofill: _angular_core.Signal<boolean>;
+    /**
+     * Model i formularz dla aktualnej kategorii. Budowane w efekcie, nie w `computed()`,
+     * bo `form()` zakłada dwie rzeczy, których ciało `computed()` nie spełnia:
+     *
+     * - wstrzykuje sobie zależności → stąd `runInInjectionContext`;
+     * - zakłada własny `effect()`, a tego nie wolno tworzyć w kontekście reaktywnym
+     *   (NG0602) → stąd `untracked`, które zdejmuje aktywnego konsumenta.
+     *
+     * Zależność od `fields()` zostaje śledzona na zewnątrz `untracked`, więc zmiana
+     * kategorii przebudowuje formularz — inny zestaw pól to inny formularz, a Signal Forms
+     * wiąże schemę tylko raz, przy tworzeniu.
+     */
+    private readonly built;
+    constructor();
+    /**
+     * Podpowiada adres z geokodowania wstecznego współrzędnych kliknięcia.
+     *
+     * Wypełnia wyłącznie pola z `autofill` i wyłącznie te, które są jeszcze puste —
+     * podpowiedź nigdy nie kasuje tego, co użytkownik zdążył wpisać. Brak portu
+     * `KPT_MAP_GEOCODER` albo nieudane zapytanie to nie błąd: pola zostają puste.
+     */
+    private watchGeocoder;
+    /** `null` tylko między utworzeniem komponentu a pierwszym przebiegiem efektu. */
+    protected readonly formRoot: _angular_core.Signal<_angular_forms_signals.FieldTree<Record<string, unknown>, string | number, "writable"> | null>;
+    protected readonly formInvalid: _angular_core.Signal<boolean>;
+    /** Kontrolka pola po kluczu — szablon podaje ją do `[formField]`. */
+    protected fieldOf(key: string): unknown;
+    /** Komunikat pokazujemy dopiero po dotknięciu pola — bramka żyje w prezentacji. */
+    protected errorOf(key: string): string | null;
+    /**
+     * Dzień otwarty musi mieć obie godziny i różne od siebie. Dzień oznaczony jako
+     * zamknięty przechodzi bez zastrzeżeń — to prawidłowa odpowiedź, a nie brak danych.
+     */
+    private hoursError;
+    protected optionsOf(def: KptMapFieldDef): KptOption<unknown>[];
+    protected controlId(def: KptMapFieldDef): string;
+    /** Czy pole renderuje jeden `<input>`, na który może wskazać `label[for]`. */
+    protected hasOwnInput(def: KptMapFieldDef): boolean;
+    /** Współrzędne z prawego kliknięcia — pokazujemy je, ale nie pozwalamy edytować. */
+    protected readonly coords: _angular_core.Signal<{
+        lat: string;
+        lng: string;
+    }>;
+    protected onSubmit(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMapCreateDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptMapCreateDialog, "kpt-map-create-dialog", never, { "category": { "alias": "category"; "required": true; "isSignal": true; }; "at": { "alias": "at"; "required": true; "isSignal": true; }; "geocoder": { "alias": "geocoder"; "required": false; "isSignal": true; }; }, { "save": "save"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+/** Minuta doby dla `HH:MM`; `24:00` to 1440. `null`, gdy zapis jest nieprawidłowy. */
+declare function parseTime(value: string): number | null;
+/** `HH:MM` z minuty doby. 1440 wraca jako `24:00`, nie `00:00`. */
+declare function formatTime(minutes: number): string;
+/** Dzień tygodnia wg ISO (1 = poniedziałek) z natywnej daty. */
+declare function isoWeekday(date: Date): KptMapWeekday;
+/**
+ * Czy miejsce jest otwarte w danym momencie.
+ *
+ * Sprawdza dwa dni: bieżący oraz poprzedni, bo przedział przez północ
+ * (`22:00 – 01:00`) obejmuje wczesne godziny dnia następnego.
+ */
+declare function isOpenAt(hours: KptMapOpeningHours | undefined, date: Date): boolean;
+/** Czy rozkład to pełna doba przez siedem dni — wtedy karta pisze po prostu „24/7". */
+declare function isAlwaysOpen(hours: KptMapOpeningHours | undefined): boolean;
+/** Najbliższa zmiana stanu otwarte/zamknięte albo `null`, gdy w ciągu tygodnia jej nie ma. */
+declare function nextChange(hours: KptMapOpeningHours | undefined, date: Date): {
+    open: boolean;
+    at: Date;
+} | null;
+/** Skrócona nazwa dnia z `Intl` — bez słownika, więc działa dla dowolnego locale. */
+declare function weekdayName(day: KptMapWeekday, locale: string): string;
+/** Wiersz rozkładu: jeden dzień albo sklejony zakres dni o identycznych godzinach. */
+interface KptMapHoursGroup {
+    /** `pon.` albo `wt.–sob.`, wg locale. */
+    label: string;
+    days: KptMapWeekday[];
+    closed: boolean;
+    /** Sformatowane przedziały, np. `['11:00 – 24:00']`. Puste, gdy zamknięte. */
+    ranges: string[];
+}
+/**
+ * Rozkład tygodnia z sąsiadującymi dniami sklejonymi w jeden wiersz.
+ *
+ * Niedziela i poniedziałek się nie sklejają, choć w tablicy sąsiadują — tydzień
+ * czyta się liniowo od poniedziałku i zawijanie byłoby mylące.
+ */
+declare function groupWeek(hours: KptMapOpeningHours | undefined, locale: string, separator?: string): KptMapHoursGroup[];
+/** Siedem dni oznaczonych jako zamknięte — wartość startowa pola `hours` w formularzu. */
+declare function emptyWeek(): KptMapOpeningHours;
+
+/** Wiersz kontaktu: wartość, akcja właściwa i kopiowanie do schowka. */
+interface ContactRow {
+    kind: 'phone' | 'email' | 'website' | 'coords';
+    icon: string;
+    /** Tekst pokazywany użytkownikowi. */
+    text: string;
+    /** Tekst kopiowany do schowka — dla współrzędnych inny niż wyświetlany. */
+    copyValue: string;
+    /** `href` akcji właściwej; `null` dla współrzędnych (nie ma dokąd prowadzić). */
+    href: string | null;
+    /** Otworzyć w nowej karcie. */
+    external: boolean;
+    actionIcon: string;
+    actionLabel: string;
+}
+/**
+ * Karta miejsca do popupu mapy — dystans od użytkownika, zdjęcie, akcje, kategoria,
+ * rozwijane godziny otwarcia i wiersze kontaktowe z kopiowaniem.
+ *
+ * Komponent jest sterowany danymi: bierze `KptMapPoi`, a nie model domenowy aplikacji.
+ * Mapowanie `KptMapLocation.data` → `KptMapPoi` robi aplikacja, dzięki czemu karta nie
+ * wie nic o tym, czy pokazuje ładowarkę, restaurację, czy punkt serwisowy.
+ *
+ * Sam popup `kpt-map` trzeba przełączyć na `[popupLayout]="'card'"` — inaczej karta
+ * dostanie 20 rem szerokości i padding przeznaczony dla treści tekstowej.
+ *
+ * @example
+ * <kpt-map [locations]="places()" [categories]="categories" popupLayout="card">
+ *   <ng-template kptMapPopup let-loc let-d="data" let-dist="distance" let-close="close">
+ *     <kpt-map-poi-card
+ *       [poi]="poiOf(loc, d)"
+ *       [distance]="dist"
+ *       [category]="categoryOf(loc)"
+ *       primaryLabel="Wyznacz trasę"
+ *       (closed)="close()"
+ *     />
+ *   </ng-template>
+ * </kpt-map>
+ */
+declare class KptMapPoiCard {
+    readonly poi: _angular_core.InputSignal<KptMapPoi>;
+    /** Odległość w metrach; `null` chowa wiersz dystansu. */
+    readonly distance: _angular_core.InputSignal<number | null>;
+    /** Źródło ikony, koloru i etykiety wiersza kategorii; `null` chowa ten wiersz. */
+    readonly category: _angular_core.InputSignal<KptMapCategory | null>;
+    /** Etykieta przycisku głównego; pusta chowa przycisk. */
+    readonly primaryLabel: _angular_core.InputSignal<string>;
+    readonly showShare: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showFavourite: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly favourite: _angular_core.ModelSignal<boolean>;
+    readonly closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Rozwinąć godziny od razu. Domyślnie zwinięte, jak na karcie miejsca w mapach. */
+    readonly hoursExpanded: _angular_core.ModelSignal<boolean>;
+    readonly primaryAction: _angular_core.OutputEmitterRef<KptMapPoi>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly shared: _angular_core.OutputEmitterRef<KptMapPoi>;
+    protected readonly i18n: KptI18n;
+    /** Identyfikator regionu godzin; kart na stronie bywa więcej niż jedna. */
+    protected readonly hoursId: string;
+    /** Rośnie przy każdym otwarciu karty i przy zmianie danych — odświeża status godzin. */
+    private readonly now;
+    /**
+     * Ikona kategorii stoi wprost na powierzchni karty, bez własnego tła — stąd
+     * `foregroundVarOf()`, a nie `colorVarOf()`: rola `muted` ma kolor tła, nie treści.
+     */
+    protected readonly categoryColor: _angular_core.Signal<string | null>;
+    protected readonly distanceLabel: _angular_core.Signal<string | null>;
+    protected readonly hasHours: _angular_core.Signal<boolean>;
+    protected readonly alwaysOpen: _angular_core.Signal<boolean>;
+    protected readonly open: _angular_core.Signal<boolean>;
+    protected readonly hoursGroups: _angular_core.Signal<KptMapHoursGroup[]>;
+    protected readonly statusLabel: _angular_core.Signal<string>;
+    /** Dopisek „otwarcie o 11:00" — nie ma go dla 24/7 ani gdy zmiana jest dalej niż doba. */
+    protected readonly statusHint: _angular_core.Signal<string | null>;
+    protected readonly rows: _angular_core.Signal<ContactRow[]>;
+    /** Klucz wiersza, którego wartość właśnie skopiowano — przełącza ikonę na „check". */
+    protected readonly justCopied: _angular_core.WritableSignal<string | null>;
+    private copyTimer;
+    /** Bez API schowka przycisk kopiowania w ogóle się nie renderuje. */
+    protected readonly canCopy: boolean;
+    protected readonly canShare: boolean;
+    protected copy(row: ContactRow): Promise<void>;
+    protected onPrimary(): void;
+    protected onClose(): void;
+    protected toggleFavourite(): void;
+    protected toggleHours(): void;
+    /**
+     * Udostępnianie: natywny arkusz systemowy, gdy przeglądarka go ma, inaczej schowek.
+     * W obu przypadkach leci `shared`, więc aplikacja może dołożyć własną telemetrię.
+     */
+    protected share(): Promise<void>;
+    protected favouriteLabel(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMapPoiCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptMapPoiCard, "kpt-map-poi-card", never, { "poi": { "alias": "poi"; "required": true; "isSignal": true; }; "distance": { "alias": "distance"; "required": false; "isSignal": true; }; "category": { "alias": "category"; "required": false; "isSignal": true; }; "primaryLabel": { "alias": "primaryLabel"; "required": false; "isSignal": true; }; "showShare": { "alias": "showShare"; "required": false; "isSignal": true; }; "showFavourite": { "alias": "showFavourite"; "required": false; "isSignal": true; }; "favourite": { "alias": "favourite"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "hoursExpanded": { "alias": "hoursExpanded"; "required": false; "isSignal": true; }; }, { "favourite": "favouriteChange"; "hoursExpanded": "hoursExpandedChange"; "primaryAction": "primaryAction"; "closed": "closed"; "shared": "shared"; }, never, never, true, never>;
+}
+
+/** Wiersz edytora — dzień z nazwą i przedziałami dopełnionymi do pustych pól. */
+interface HoursRow {
+    day: KptMapWeekday;
+    name: string;
+    closed: boolean;
+    ranges: {
+        from: string;
+        to: string;
+    }[];
+}
+/**
+ * Pole „godziny otwarcia" formularza dodawania lokalizacji (`type: 'hours'` w schemie).
+ *
+ * Siedem wierszy od poniedziałku, każdy z parą godzin i znacznikiem „zamknięte".
+ * Skrót „tak samo przez cały tydzień" kopiuje poniedziałek na pozostałe dni — to
+ * najczęstszy przypadek, a bez niego wypełnienie formularza to czternaście pól.
+ *
+ * Nazwy dni idą z `Intl`, nie ze słownika `KptMessages`: rozkład tygodnia jest
+ * uniwersalny, a tłumaczenie nazw dni przeglądarka ma już zrobione.
+ */
+declare class KptMapHoursField implements FormValueControl<KptMapOpeningHours> {
+    readonly value: _angular_core.ModelSignal<KptMapOpeningHours>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected readonly i18n: KptI18n;
+    protected readonly maxRanges = 2;
+    protected readonly minuteStep = 5;
+    /** Skrót „tak samo przez cały tydzień" — trzymany w modelu, nie w wartości. */
+    readonly sameAllWeek: _angular_core.ModelSignal<boolean>;
+    protected readonly rows: _angular_core.Signal<HoursRow[]>;
+    /** Dni poza poniedziałkiem są zablokowane, gdy tydzień jest jednakowy. */
+    protected locked(row: HoursRow): boolean;
+    protected onSameAllWeek(same: boolean): void;
+    protected setClosed(row: HoursRow, closed: boolean): void;
+    protected setTime(row: HoursRow, index: number, edge: 'from' | 'to', time: string): void;
+    protected addRange(row: HoursRow): void;
+    protected removeRange(row: HoursRow, index: number): void;
+    /** Zmiana jednego dnia; przy jednakowym tygodniu poniedziałek rozlewa się na resztę. */
+    private patch;
+    /** Zapis zawsze przez pełny, uporządkowany tydzień — model nie ma dziur. */
+    private write;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMapHoursField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptMapHoursField, "kpt-map-hours-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "sameAllWeek": { "alias": "sameAllWeek"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; "sameAllWeek": "sameAllWeekChange"; }, never, never, true, never>;
+}
+
+/**
+ * Pole „zdjęcie" formularza dodawania lokalizacji (`type: 'image'` w schemie kategorii).
+ *
+ * Wartością jest zawsze **string**: albo `data:` z wybranego pliku, albo adres wklejony
+ * przez użytkownika. Karta miejsca nie rozróżnia jednego od drugiego, więc formularz
+ * nie musi decydować za aplikację, gdzie zdjęcia mieszkają.
+ *
+ * Plik czytamy w przeglądarce i nigdzie nie wysyłamy — biblioteka nie ma i nie chce
+ * mieć wiedzy o storage'u aplikacji.
+ */
+declare class KptMapImageField implements FormValueControl<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Górny limit pliku w bajtach. */
+    readonly maxBytes: _angular_core.InputSignal<number>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected readonly i18n: KptI18n;
+    /** Pliki trzymane wyłącznie po to, żeby `kpt-file-upload` miał co pokazać. */
+    protected readonly files: _angular_core.ModelSignal<File[]>;
+    /** Komunikat o zbyt dużym pliku; walidacja rozmiaru nie ma sensu w schemie. */
+    protected readonly sizeError: _angular_core.WritableSignal<string | null>;
+    protected readonly urlValue: _angular_core.Signal<string>;
+    protected readonly preview: _angular_core.Signal<string | null>;
+    protected readonly maxLabel: _angular_core.Signal<string>;
+    protected onFiles(files: File[]): void;
+    protected onUrl(url: string): void;
+    protected clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMapImageField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptMapImageField, "kpt-map-image-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "maxBytes": { "alias": "maxBytes"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; "files": "filesChange"; }, never, never, true, never>;
+}
+
+/**
+ * Namespace `google.maps`. Świadomie `any` — pełne typy przychodzą z opcjonalnego
+ * `@types/google.maps`, a biblioteka nie może od nich zależeć przy kompilacji.
+ */
+type KptGoogleMapsApi = any;
+interface KptGoogleOptions {
+    /** Klucz API z Google Cloud. Wymagany. */
+    apiKey: string;
+    /**
+     * Identyfikator stylu mapy z konsoli Google (*Map management → Create Map ID*).
+     *
+     * **Wymagany.** Bez niego nie działa `AdvancedMarkerElement`, a znaczniki tej biblioteki
+     * to gotowy HTML z `marker-html.ts` — starsze `Marker` nie umie go przyjąć.
+     */
+    mapId: string;
+    /** Wersja API. Domyślnie `weekly`. */
+    version?: string;
+    /** Język etykiet na mapie (kod ISO 639-1). Domyślnie język przeglądarki. */
+    language?: string;
+    /** Region wpływający na nazewnictwo i granice sporne (ISO 3166-1 alpha-2). */
+    region?: string;
+    /** Dolny limit zoomu. Domyślnie 2 — niżej świat powtarza się w poziomie. */
+    minZoom?: number;
+    /** Górny limit zoomu. Domyślnie 21. */
+    maxZoom?: number;
+    /** Zoom kółkiem myszy. Domyślnie włączony. */
+    scrollWheelZoom?: boolean;
+}
+/**
+ * Tyle z `KptGoogleOptions`, ile trzeba do wczytania samego API. Bez `mapId` — ten dotyczy
+ * wyglądu mapy, a API potrzebują też usługi, które żadnej mapy nie rysują.
+ */
+type KptGoogleLoadOptions = Pick<KptGoogleOptions, 'apiKey' | 'version' | 'language' | 'region'>;
+/**
+ * Ładuje Google Maps JavaScript API raz na aplikację. Gdy `google.maps` już istnieje — bo
+ * aplikacja wstawiła skrypt sama albo stoi tu druga mapa — korzystamy z tego, co jest: drugie
+ * wczytanie Google i tak odrzuca, wypisując ostrzeżenie do konsoli.
+ *
+ * Publiczne, bo silnik nie jest jedynym, kto tego API potrzebuje. Geokoder Google **musi**
+ * iść przez SDK, a nie przez REST: web service `/maps/api/geocode/json` odrzuca klucze
+ * z restrykcją `Referer` („API keys with referer restrictions cannot be used with this API"),
+ * a to jedyna restrykcja, jaką da się sensownie nałożyć na klucz leżący w bundlu przeglądarki.
+ * Wywołania z załadowanego SDK autoryzują się tak samo jak sama mapa.
+ *
+ * Adaptera geokodera biblioteka nadal nie dostarcza — tylko drogę do API, którą i tak
+ * otwiera silnikowi. Powody stoją przy `provideKptGoogleMap` i w `llms.txt`.
+ */
+declare function loadGoogleMapsApi(options: KptGoogleLoadOptions): Promise<KptGoogleMapsApi>;
+/** Fabryka silnika — każda mapa dostaje własną instancję. */
+declare function createGoogleEngine(options: KptGoogleOptions): KptMapEngine;
+
+interface KptLeafletOptions {
+    /** Dolny limit zoomu. Domyślnie 2 — niżej świat powtarza się w poziomie. */
+    minZoom?: number;
+    /** Górny limit zoomu. Domyślnie 19 (tyle daje OSM). */
+    maxZoom?: number;
+    /** Bezwładność po przeciągnięciu. Domyślnie włączona. */
+    inertia?: boolean;
+    /** Zoom kółkiem myszy. Domyślnie włączony. */
+    scrollWheelZoom?: boolean;
+}
+/** Fabryka silnika — każda mapa dostaje własną instancję. */
+declare function createLeafletEngine(options?: KptLeafletOptions): KptMapEngine;
+
+/**
+ * Fabryka silnika mapy. Fabryka, a nie gotowa instancja — każda mapa na stronie
+ * potrzebuje własnego obiektu, a provider jest jeden.
+ */
+declare const KPT_MAP_ENGINE: InjectionToken<KptMapEngineFactory>;
+/**
+ * Silnik Leaflet + OpenStreetMap. Wymaga zainstalowanej paczki `leaflet`
+ * (zależność opcjonalna) i dołączonego `leaflet/dist/leaflet.css`.
+ *
+ * @example
+ * // main.ts
+ * bootstrapApplication(App, { providers: [provideKptLeafletMap()] });
+ */
+declare function provideKptLeafletMap(options?: KptLeafletOptions): Provider[];
+/**
+ * Silnik Google Maps. Nie wymaga żadnej paczki npm — API dogrywa się skryptem przy pierwszej
+ * mapie — ale wymaga klucza, konta rozliczeniowego i **`mapId`** z konsoli Google
+ * (*Map management → Create Map ID*): bez niego znaczniki się nie pojawią.
+ *
+ * Różnice wobec Leafleta: `[tileUrl]` i `[attribution]` są bez znaczenia (kafle i atrybucję
+ * dostarcza Google i nie wolno ich zasłonić), wczytanie mapy liczy się do SKU Dynamic Maps
+ * (10 000 miesięcznie za darmo), a zoom bywa ułamkowy.
+ *
+ * **To jedyny silnik, z którym wolno użyć geokodera Google.** Service Specific Terms §6.2
+ * i §14.2 zabraniają pokazywać wyniki Geocoding API i Places API razem z mapą nie-Google,
+ * a więc także z domyślnym Leafletem tej biblioteki.
+ *
+ * @example
+ * // main.ts
+ * providers: [provideKptGoogleMap({ apiKey: env.googleMapsKey, mapId: env.googleMapId })]
+ */
+declare function provideKptGoogleMap(options: KptGoogleOptions): Provider[];
+
+/**
+ * Źródło pozycji użytkownika. Port, a nie bezpośrednie `navigator.geolocation` — dzięki
+ * temu Storybook i testy podstawiają stałą pozycję zamiast pytać przeglądarkę o zgodę.
+ */
+interface KptMapGeolocationPort {
+    /**
+     * Strumień pozycji. `null` oznacza brak odczytu (brak zgody, wyłączony GPS, SSR).
+     * Subskrypcja rozpoczyna nasłuch, a jej zamknięcie go kończy.
+     */
+    watch(options?: PositionOptions): Observable<KptMapUserPosition | null>;
+}
+declare const KPT_MAP_GEOLOCATION: InjectionToken<KptMapGeolocationPort>;
+/** Błąd geolokalizacji rozpoznany po kodzie — rzucany strumieniem, nie wyjątkiem. */
+declare class KptMapGeolocationFailure extends Error {
+    readonly detail: KptMapGeolocationError;
+    constructor(detail: KptMapGeolocationError);
+}
+/**
+ * Domyślna implementacja na `navigator.geolocation.watchPosition`.
+ *
+ * Uwaga: Geolocation API działa wyłącznie w bezpiecznym kontekście (HTTPS albo
+ * `localhost`). Na `http://` z adresem IP przeglądarka odmówi — to nie jest błąd mapy.
+ */
+declare class KptBrowserGeolocation implements KptMapGeolocationPort {
+    watch(options?: PositionOptions): Observable<KptMapUserPosition | null>;
+}
+/** Stała pozycja — Storybook, testy, demo bez pytania o zgodę. */
+declare class KptMapGeolocationStub implements KptMapGeolocationPort {
+    private readonly at;
+    private readonly accuracy;
+    constructor(at: KptLatLng, accuracy?: number);
+    watch(): Observable<KptMapUserPosition | null>;
+}
+/**
+ * Podstawia stałą pozycję zamiast prawdziwej geolokalizacji.
+ *
+ * @example
+ * providers: [provideKptMapGeolocationStub({ lat: 52.23, lng: 21.01 })]
+ */
+declare function provideKptMapGeolocationStub(at: KptLatLng, accuracy?: number): Provider;
+
+interface KptMapCountryPreset {
+    /** Kod ISO 3166-1 alpha-2 (albo `EU` dla całego kontynentu). */
+    code: string;
+    center: KptLatLng;
+    /** Zoom, przy którym kraj mieści się na typowym kontenerze (~1000×600 px). */
+    zoom: number;
+    bounds: KptMapBounds;
+}
+/** Kod kraju użyty, gdy aplikacja nie poda żadnego. */
+declare const KPT_MAP_DEFAULT_COUNTRY = "PL";
+/**
+ * Zasięgi lądowe (bez terytoriów zamorskich) zaokrąglone do dwóch miejsc —
+ * to widok startowy, nie granica administracyjna.
+ */
+declare const KPT_MAP_COUNTRIES: Record<string, KptMapCountryPreset>;
+/** Preset kraju po kodzie (wielkość liter bez znaczenia); `undefined`, gdy nieznany. */
+declare function countryPreset(code: string): KptMapCountryPreset | undefined;
+/** Kody wszystkich presetów — do listy wyboru w aplikacji. */
+declare function countryCodes(): string[];
+/**
+ * Widok startowy: preset kraju, a przy nieznanym kodzie preset domyślny.
+ * Zawsze zwraca coś sensownego — mapa nigdy nie startuje na `[0, 0]`.
+ */
+declare function resolveCountryView(code: string | null | undefined): KptMapCountryPreset;
+/** Środek prostokąta kraju — pomocnicze przy własnych `bounds`. */
+declare function centerOfBounds(bounds: KptMapBounds): KptLatLng;
+
+/** Bok kafla w pikselach — stała obu silników. */
+declare const KPT_TILE_SIZE = 256;
+/**
+ * Granica szerokości w Mercatorze. Powyżej niej projekcja ucieka do nieskończoności,
+ * więc obie biblioteki przycinają świat dokładnie w tym miejscu.
+ */
+declare const KPT_MAX_LATITUDE = 85.05112877980659;
+/** Promień Ziemi w metrach (sfera, jak w Leaflet `L.CRS.Earth`). */
+declare const KPT_EARTH_RADIUS = 6378137;
+/** Przycina szerokość do zakresu obsługiwanego przez Mercator. */
+declare function clampLat(lat: number): number;
+/**
+ * Zawija długość geograficzną do zakresu [-180, 180].
+ *
+ * Wartości już w zakresie wracają nietknięte — także -180, bo w projekcji jest to
+ * lewa krawędź świata (x = 0), a nie ta sama kolumna pikseli co +180. Zawijanie
+ * dotyczy wyłącznie tego, co wychodzi poza zakres: 540° to ten sam południk co 180°.
+ */
+declare function normalizeLng(lng: number): number;
+/** Liczba pikseli świata na danym zoomie. */
+declare function worldSize(zoom: number): number;
+/** Współrzędne → piksele świata na danym zoomie (origin w lewym górnym rogu). */
+declare function project(at: KptLatLng, zoom: number): KptMapPoint;
+/** Piksele świata → współrzędne. Odwrotność `project`. */
+declare function unproject(point: KptMapPoint, zoom: number): KptLatLng;
+/** Najmniejszy prostokąt obejmujący wszystkie punkty. Pusta lista → `null`. */
+declare function boundsOf(points: readonly KptLatLng[]): KptMapBounds | null;
+/**
+ * Najmniejszy zasięg w stopniach, przy którym `fitBounds` ma jeszcze sens (~100 m).
+ *
+ * Geokodery obrysowują pojedynczy adres prostokątem rzędu 0,0001°. Wpasowanie takiego
+ * w kadr wjeżdża na górny limit zoomu, a wynik zależy od tego, jak dostawca obrysował
+ * budynek — dwa sąsiednie adresy lądują w różnych przybliżeniach.
+ */
+declare const KPT_MIN_FIT_SPAN = 0.001;
+/**
+ * Czy prostokąt warto wpasowywać w kadr, zamiast potraktować go jak punkt.
+ *
+ * `false` dla zasięgu zdegenerowanego albo ciaśniejszego niż `minSpan` w OBU osiach —
+ * długa, wąska ulica ma jeden wymiar mikroskopijny i dalej zasługuje na `fitBounds`.
+ */
+declare function isFittableBounds(bounds: KptMapBounds, minSpan?: number): boolean;
+/** Środek prostokąta. */
+declare function boundsCenter(bounds: KptMapBounds): KptLatLng;
+/** Czy punkt leży w prostokącie (granice włącznie). */
+declare function boundsContain(bounds: KptMapBounds, at: KptLatLng): boolean;
+/** Rozszerza prostokąt o zadaną liczbę stopni w każdą stronę. */
+declare function padBounds(bounds: KptMapBounds, degrees: number): KptMapBounds;
+/** Odległość po wielkim kole w metrach. */
+declare function haversine(a: KptLatLng, b: KptLatLng): number;
+/**
+ * Ile metrów przypada na piksel na danej szerokości i zoomie.
+ * Potrzebne, żeby krąg dokładności geolokalizacji miał realny promień.
+ */
+declare function metersPerPixel(lat: number, zoom: number): number;
+/**
+ * Największy zoom, przy którym `bounds` mieści się w kontenerze o zadanym rozmiarze.
+ * Zwraca liczbę zmiennoprzecinkową — zaokrąglenie w dół zostawiamy wołającemu.
+ */
+declare function zoomForBounds(bounds: KptMapBounds, size: {
+    width: number;
+    height: number;
+}, paddingPx?: number): number;
+
+/** Rola koloru → zmienna CSS. Gotowe `var(--kpt-*)` przechodzi bez zmian. */
+declare function colorVarOf(color: KptMapColor): string;
+/** Kolor treści na tle `color` — dla ról znany, dla własnych zmiennych fallback na biel tokenową. */
+declare function contrastVarOf(color: KptMapColor): string;
+declare function foregroundVarOf(color: KptMapColor): string;
+interface KptMarkerHtmlInput {
+    shape?: KptMapMarkerShape;
+    color: KptMapColor;
+    /** Inner-SVG ikony (bez wrappera `<svg>`); bez niego znacznik nie ma glifu. */
+    iconSvgInner?: string;
+    /** Tekst dla czytnika ekranu — zwykle tytuł lokalizacji. */
+    label: string;
+    /** Znacznik wybrany (otwarty popup) — dostaje klasę modyfikującą. */
+    selected?: boolean;
+}
+declare function renderMarkerHtml(input: KptMarkerHtmlInput): string;
+interface KptClusterHtmlInput {
+    count: number;
+    color: KptMapColor;
+    /** Gotowy tekst dla czytnika (i18n rozwiązane po stronie Angulara). */
+    label: string;
+}
+/** Koło z licznikiem; rozmiar rośnie schodkowo z liczebnością grupy. */
+declare function renderClusterHtml(input: KptClusterHtmlInput): string;
+/** Próg wielkości grupy — trzy stopnie wystarczą, żeby zobaczyć różnicę bez skalowania ciągłego. */
+declare function clusterTier(count: number): 'sm' | 'md' | 'lg';
+/** Znacznik pozycji użytkownika — ikona podawana z zewnątrz, jak przy zwykłym znaczniku. */
+declare function renderUserMarkerHtml(input: {
+    label: string;
+    iconSvgInner?: string;
+}): string;
+
+/**
+ * Dystans po ludzku: poniżej kilometra w metrach zaokrąglonych do dziesiątek,
+ * wyżej w kilometrach z jednym miejscem po przecinku (`6,2 km` w `pl-PL`).
+ *
+ * Wartość ujemna albo nieskończona daje `null` — wołający chowa wtedy wiersz,
+ * zamiast malować „NaN km".
+ */
+declare function formatDistance(metres: number | null | undefined, locale: string): string | null;
+/** Współrzędne do wiersza karty — pięć miejsc po przecinku to ok. metr. */
+declare function formatLatLng(at: {
+    lat: number;
+    lng: number;
+}, digits?: number): string;
+
+export { KPT_CLUSTER_DEFAULTS, KPT_EARTH_RADIUS, KPT_MAP_COUNTRIES, KPT_MAP_DEFAULT_ATTRIBUTION, KPT_MAP_DEFAULT_COUNTRY, KPT_MAP_DEFAULT_TILE_URL, KPT_MAP_ENGINE, KPT_MAP_GEOCODER, KPT_MAP_GEOLOCATION, KPT_MAX_LATITUDE, KPT_MIN_FIT_SPAN, KPT_TILE_SIZE, KptBrowserGeolocation, KptMap, KptMapCreateDialog, KptMapCreateFormTemplate, KptMapGeocoderStub, KptMapGeolocationFailure, KptMapGeolocationStub, KptMapHoursField, KptMapImageField, KptMapLegend, KptMapPoiCard, KptMapPopupTemplate, KptMapSearch, KptNominatimGeocoder, boundsCenter, boundsContain, boundsOf, centerOfBounds, clampLat, clusterLocations, clusterTier, colorVarOf, contrastVarOf, countByCategory, countryCodes, countryPreset, createGoogleEngine, createLeafletEngine, dominantCategory, emptyWeek, foregroundVarOf, formatDistance, formatLatLng, formatTime, groupWeek, haversine, isAlwaysOpen, isCluster, isFittableBounds, isOpenAt, isSplittable, isoWeekday, loadGoogleMapsApi, metersPerPixel, nextChange, normalizeLng, padBounds, parseTime, project, provideKptGoogleMap, provideKptLeafletMap, provideKptMapGeocoderStub, provideKptMapGeolocationStub, provideKptNominatimGeocoder, renderClusterHtml, renderMarkerHtml, renderUserMarkerHtml, resolveCountryView, unproject, weekdayName, worldSize, zoomForBounds };
+export type { KptClusterOptions, KptGoogleLoadOptions, KptGoogleMapsApi, KptGoogleOptions, KptLatLng, KptLeafletOptions, KptMapAddress, KptMapAddressPart, KptMapBounds, KptMapCategory, KptMapCluster, KptMapClusterEntry, KptMapColor, KptMapColorRole, KptMapCountryPreset, KptMapCreateEvent, KptMapCreateFormApi, KptMapCreateFormContext, KptMapDayHours, KptMapEngine, KptMapEngineEvents, KptMapEngineFactory, KptMapEngineInit, KptMapEngineKind, KptMapFieldDef, KptMapFieldOption, KptMapFieldType, KptMapGeocoderPort, KptMapGeocoderStubOptions, KptMapGeolocationError, KptMapGeolocationErrorKind, KptMapGeolocationPort, KptMapHoursGroup, KptMapHoursRange, KptMapLocation, KptMapMarkerShape, KptMapOpeningHours, KptMapPoi, KptMapPoiFact, KptMapPoint, KptMapPointerEvent, KptMapPopupContext, KptMapRenderedMarker, KptMapSearchOptions, KptMapSearchResult, KptMapSuggestion, KptMapUserPosition, KptMapView, KptMapWeekday, KptNominatimOptions };
+//# sourceMappingURL=konce-pt-angular-map.d.ts.map